C / C++ / MFC

void CTestDialog::PostNCDestroy()
{
    delete this;
}

void CTestDialog::PostNCDestroy()
{
    if( m_pSelf )
        *m_pSelf = NULL;    // null parent's pointer to us
    delete this;
}

BEGIN
    CONTROL         "",IDC_MNG_TAB,"SysTabControl32",0x0,17,25,248,300
    PUSHBUTTON      "Edit",IDC_MNG_EDIT,31,345,51,14,WS_GROUP
    PUSHBUTTON      "Apply",IDC_MNG_APPLY,112,345,50,14,WS_DISABLED | WS_GROUP
    DEFPUSHBUTTON   "Cancel",IDC_MNG_CANCEL,194,345,50,14,WS_GROUP
    CONTROL         "",IDC_MAIN_TREE,"SysTreeView32",WS_BORDER | WS_HSCROLL | WS_GROUP | WS_TABSTOP,299,75,209,250
    CONTROL         "",IDC_RPT_TAB,"SysTabControl32",0x0,544,25,248,300
    PUSHBUTTON      "Execute",IDC_RPT_EXECUTE,561,345,50,14,WS_GROUP
    PUSHBUTTON      "Cancel",IDC_RPT_CANCEL,724,345,50,14,WS_GROUP
    CONTROL         284,IDC_LOGO,"Static",SS_BITMAP,299,329,209,39
    GROUPBOX        "Manage",IDC_MNG,7,7,268,369
    GROUPBOX        "Monitor",IDC_MONITOR,285,7,237,369
    GROUPBOX        "Report",IDC_RPT,532,7,268,369
    GROUPBOX        "Status",IDC_ST_STATUS,299,21,209,44
    CONTROL         0,IDC_STATUS,"Static",SS_BITMAP,324,31,159,28
END

forwardsim wrote:

All my tries give a "cannot convert parameter from something to another thing" error.

template<typename T>
class test
{
};

test<A> a;
test<B> b;

std::vector< test * > all;

std::vector< test * > all;

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]);
}