ATL / WTL / STL

CComObject<CThingy>* pThingy;
 
  if ( FAILED( CComObject<CThingy>::CreateInstance ( &pThingy ) ))
    return NULL;
 
  pThingy->AddRef();
  pThingy->SomeInternalStuff();
  return (IThingy*) pThingy;

pvMyClass->pvOC->clear();

pvMyClass->OtherClass::pvOC->clear();

class MyClass
{
   // other statements
   static vector<OtherClass> vOC;
};
=================
Then later:
vOC->pvOC->clear();  // pvOC is defined in OtherClass as vector<string> *pvOC;

class MyClass{
    vector<OtherClass> *pvMyClass;
};
MyClass::MyClass(){
    pvMyClass = new vector<OtherClass>;
}
//================
class OtherClass{
    vector<string> *pvOC;
};
OtherClass::OtherClass(){   
    pvOC = new vector<string>;
}
//====================
OtherClass oc = OtherClass();
oc.pvOC->clear();
pvMyClass->push_back(oc);

class MyClass{
    vector<OtherClass> *pvMyClass;
};
MyClass::MyClass(){
    pvMyClass = new vector<OtherClass>;
}
//================
class OtherClass{
    // Make pvOC static.
    static vector<string> *pvOC;
};
// The following is in the implementation.
vector<string> *OtherClass::pvOC =
  new vector<string>;
OtherClass::OtherClass(){   
    // Nothing.
}
//====================
pvMyClass->push_back(OtherClass());
OtherClass::pvOC->clear();

#include <vector>

using namespace std;

class OtherClass
{
   vector<string> vOC;

   public:
      void AddString( const char* str )
         {
         vOC.push_back( str );
         }
};

class MyClass
{
   vector<OtherClass> vMyClass;

   public:
      void AddElements();
};


void MyClass::AddElements()
{
   vMyClass.push_back( OtherClass() );
   OtherClass& oc = vMyClass.back();
   oc.AddString( "First" );
   oc.AddString( "Second" );
   oc.AddString( "Third" );
}


int main()
   {
   MyClass mine;
   mine.AddElements();

   return 0;
   }