C / C++ / MFC

PROP_ENTRY("Picture", DISPID_PICTURE, CLSID_StockPicturePage)

HRESULT IPersistStreamInit_Load(LPSTREAM pStm, ATL_PROPMAP_ENTRY* pMap)
{
   // ------------- TRYING TO LOAD THE IPICTURE
   CComPtr<IPictureDisp> pic;
   LARGE_INTEGER l;
   l.QuadPart  =0;
   pStm->Seek(l, STREAM_SEEK_SET, NULL);


   OleLoadPicture(pStm, l.LowPart, FALSE, IID_IPictureDisp, (void **) &pic);
   if(pic) {
      _Pict = pic;
   }
   // -------------


   HRESULT hr = MyAtlIPersistStreamInit_Load(pStm, pMap, this,
                   (IUnknown*)(IDispatch*)this);
   if (SUCCEEDED(hr))
      m_bRequiresSave = FALSE;
   return hr;
}

HRESULT IPersistStreamInit_Save(LPSTREAM pStm, BOOL fClearDirty,
        ATL_PROPMAP_ENTRY* pMap)
{
   // ------------- TRYING TO SAVE THE IPICTURE
   if(_Pict) {
      CComQIPtr<IPersistStream> p = _Pict;

      p->Save(pStm, FALSE);
   }
   // -------------


   return MyAtlIPersistStreamInit_Save(pStm, fClearDirty, pMap, this,
                   (IUnknown*)(IDispatch*)this);
}

1. The nested class lies in the private part of the nesting class,
2. or the constructors for the nested class are private and the nesting class is a friend of the nested class

Theres nothing wrong with nested classes. If CMySecondClass is only meaningful in the context of a CMyFirstClass object, then nesting the classes makes this clear.

However, if the second class is an implementation detail that doesn't appear in the public interface, there is another technique that you may be able to apply. In the header file that declares CMyFirstClass you simply give a forward reference to CMySecondClass:

class CMySecondClass; // forward declaration

class CMyFirstClass
{
  public:
  // public interface (CMySecondClass not mentioned)

  protected:
  CMySecondClass *m_p_instance;

  //protected or private member functions
  //which may include arguments of type
  //(CMySecondClass *) or (CMySecondClass&)
};

Now, both the declaration and implementation of CMySecondClass can be put in the implementation file
for CMyFirstClass. This provides much stronger encapsulation than a nested protected or private class, since the details of CMySecondClass aren't even visible to code that uses CMyFirstClass (other than the fact that CMySecondClass exists). With a nested protected or private class, the details of CMySecondClass are visible, but access is restricted.

Stephen C. Steel
Kerr Vayne Systems Ltd.