C / C++ / MFC

class base {
 public:
  virtual void accept(class visitor&) = 0;
};

template<typename T>
class impl : public base {
 public:
  virtual void accept(class visitor& v);
  
  //...

};

class visitor {
 public:
  void operator()(base* b) {
   b->accept(*this);
  }
  void visit(impl<int>& pimpl) {
   std::cout << "i am an int" << std::endl;//...
  }
  void visit(impl<double>& pimpl) {
   //...
  }
  // other overloads...
};

template<typename T>
void impl<T>::accept(visitor& v) {
 v.visit(*this);
}
  
void foo() {
 std::vector<base*> vec;
 vec.push_back(new impl<int>);
 vec.push_back(new impl<double>);
 
 //...
 visitor v;
 std::for_each(vec.begin(), vec.end(), v);

 // output:
 // i am an int
 // i am an double
 // ...
}

overloaded Name wrote:

hello guys...can we overload the main()??

void main( void )
int main( void )
void main( int argc )
int main( int argc )
void main( int argc, char *argv[] )
int main( int argc, char *argv[] )
void main( int argc, char *argv[], char *env[] )
int main( int argc, char *argv[], char *env[] )

Aescleal wrote:

main always should have a return type of int.

int main()
{
}

void main()
{
}

Aescleal wrote:

What's returned to the OS?

int main()
{
//..
}

CPallini wrote:

While I see the point of returning a value of the OS, I personally don't like 'default 0-return value' for code intended to return nothing.

2 bugs found.
> recompile ...
65534 bugs found.

void my_main( int argc, char **argv )
{
   //... your code in here...
}

int main( int argc, char **argv )
{
    my_main( argc, argv );
}

void main()
{
// whatever
}

An implementation shall not predefine the main function. This function shall not be overloaded. It shall have a return type of type int, but otherwise its type is implementation-defined.

DrFrankenstein90 wrote:

...no matter that you care about what your program returns or not.