C / C++ / MFC

#include <vector>
class base
{
public:
	template<class T>
	static void sum(T &dest, const T &src)
	{
		dest.privateadd(src);
	}
	template<class T, class U>
	static void sum(T &dest, const U &src)
	{
		// dest and src of different types, ignore
	}
private:
	template<class T>
	void privateadd(const T &t)
	{
		virtualadd(&t);
	}
	virtual void virtualadd(const base *arg) = 0;
};

template< class T >
class CTest : public base
{
public:
	T mem;
private:
	virtual void virtualadd(const base *arg)
	{
		// arg is always of type CTest<T>
		const CTest<T> *other = static_cast<const CTest<T>*>( arg );
		mem += other->mem;
	}
};

int main()
{
	std::vector<base*> all;

	CTest<int> a;
	CTest<double> b;

	base::sum(a, b); // No action
	base::sum(a, a); // Sums a and a and stores result in a
	base::sum(a, 1); // Will compile, no action taken
	// base::sum(1, a); // Will not compile
	all.push_back(&a); // Stores well in list
	all.push_back(&b); // Stores well in list
	base::sum(*all[0], *all[1]);
	base::sum(*all[0], *all[0]);
}

base::sum(*all[0], *all[1]);
base::sum(*all[0], *all[0]);

template< class T >
static void sum(T &dest, const T &src)
{
    dest.privateadd(src);
}

template<class T, class U>
static void sum(T &dest, const U &src)
{
    // dest and src of different types, ignore
}

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.