ATL / WTL / STL

<br />
class CMyClass;<br />
<br />
template< class CExtBaseWnd = CWnd><br />
class CChartWndParent : public CExtBaseWnd<br />
{<br />
....<br />
CMyClass m_classX;<br />
}<br />

template <typename T, typename SourceInterface, int ID>
class CSourceInterfaceImpl {
public:
   HRESULT Init() {
      // Create type info stuff, preferably using CreateDispTypeInfo()
      // based on the interface passed as template parameter. Feel 
      // free to use __uuidof(SourceInterface) if portability is of no
      // concern
      ...
   }
 
   void Finalize() {
      // Release type info
   }

   // Important. Do NOT implement the IUnknown part here. These 
   // methods must be implemented by the COM class so that we don't
   // break any COM rules. 
   STDMETHOD(GetIDsOfNames)(...) {
      // Implement this, preferably using DispGetIDsOfNames()
   }
 
   STDMETHOD(GetTypeInfo)(...) {
      // pass back the type info object created in constructor
   }
 
   STDMETHOD(GetTypeInfoCount)(...) {
      // Return 1
   }
 
   STDMETHOD(Invoke)(...) {
      // this is where we dispatch the calls to "the one and only"
      // function. 
      return static_cast<T>(this)->EventInvocation(
         ID, 
         ... // The rest of the parameters passed to this function
      );
   }
};
 
#define ID_FOR_EVENTS_X 1
#define ID_FOR_EVENTS_Y 2
#define ID_FOR_EVENTS_Z 3

class ATL_NO_VTABLE CMyCOMClass : 
   public ..., // boiler plate ATL code
   // This is where we reuse the CSourceInterfaceImpl template
   public CSourceInterfaceImpl<CMyCOMClass, ISourceX, ID_FOR_EVENTS_X>,
   public CSourceInterfaceImpl<CMyCOMClass, ISourceY, ID_FOR_EVENTS_Y>,
   public CSourceInterfaceImpl<CMyCOMClass, ISourceZ, ID_FOR_EVENTS_Z>
{
   ... // ATL boiler plate code
   HRESULT FinalConstruct() {
      HRESULT hr; // handling of errors omitted for brevity
      hr = CSourceInterfaceImpl<CMyCOMClass, ISourceX, ID_FOR_EVENTS_X>::Init();
      hr = CSourceInterfaceImpl<CMyCOMClass, ISourceY, ID_FOR_EVENTS_Y>::Init();
      hr = CSourceInterfaceImpl<CMyCOMClass, ISourceZ, ID_FOR_EVENTS_Z>::Init();
   }
 
   void FinalRelease() {
      CSourceInterfaceImpl<CMyCOMClass, ISourceX, ID_FOR_EVENTS_X>::Finalize();
      CSourceInterfaceImpl<CMyCOMClass, ISourceY, ID_FOR_EVENTS_Y>::Finalize();
      CSourceInterfaceImpl<CMyCOMClass, ISourceZ, ID_FOR_EVENTS_Z>::Finalize();
   }
 
   // This is the "magic function" which will receive all calls
   // when the interfaces ISourceX, ISourceY and ISourceZ has been
   // sunk.
   HRESULT EventInvocation(int nId, ... /* std IDispatch::Invoke args*/) {
      switch(nId) {
          case ID_FOR_EVENTS_X:
             // Do your thing for ISourceX
          break;
          case ID_FOR_EVENTS_Y:
             // Do your thing for ISourceY
          break;
          case ID_FOR_EVENTS_Z:
             // Do your thing for ISourceZ
          break;
          default:
             ATLASSERT(false); // where did this come from?!
             return E_NOTIMPL;
      }
   }
}

struct S {
    int* p; 
    S() { p = new int[10]; }
    ~S() { delete [] p; }
};
 
{ 
  S a;
  S b(a);
} // <- when a and b falls out of scope, the ~S() will crash trying
  // to delete the same array twice.

A::A(const A& other) : a(other.a), b(other.b) { /* empty */ }