C / C++ / MFC

std::vector< test * > all;

class base {};

template< class T >
class CTest : public base
{
 // something
}

std::vector<base*> all;

class base
{
  // virtual void add( ?????????????? )=0;
};

template< class T >
class CTest : public base
{
public:
   T mem;
   void add( CTest< T > i )
   {
      // same type for this and i
      // add
      mem += i.mem;
   }

   template < class S >
   void add( CTest< S > i )
   {
     // not same type for this and i
     // do nothing
   }
};

std::vector<base*> all;

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

all.push( (base*) &a );
all.push( (base*) &b );

// the next line will not work since base doesn't implement add.
// how to make add virtual to be able to link it to the child add ????????
// I tried few things without success...
all[0]->add( all[1] );

class test
{
    public:
        virtual test &operator+=( const test &other ) = 0;
};

template <typename T>
class T_test : public test
{
    public:
	T_test( T initial ) : value_( initial )
	{
	}

        virtual test &operator+=( const test &other )
        {
		if( const T_test<T> *p = dynamic_cast<const T_test<T> *>( &other ) )
		{
			value_ += p->value_;
		}
		return *this;
        }

	private:
	    T value_;
};

int main()
try
{
	T_test<int> a( 100 );
	T_test<double> b( 100.0 );
	T_test<int> c( 200 );

	test *ptrs[] = { &a, &b, &c };
	std::vector<test *> all( ptrs, ptrs + 3 );

	T_test<int> result( 0 );

	for( std::vector<test *>::const_iterator iter = all.begin(); iter != all.end(); ++iter )
	{
		result += **iter;
	}
}
catch( const std::exception &e )
{
	std::cout << e.what() << std::endl;
}
catch( ... )
{
	std::cout << "Something went wrong, no idea what!" << std::endl;
}

#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?