Przechowywanie i ładowanie obiektów CObject za pomocą archiwum

Przechowywanie i ładowanie CObjects za pośrednictwem archiwum wymaga dodatkowych rozważań.W niektórych przypadkach powinna wywołać Serialize funkcji obiektu, gdzie CArchive obiektu jest parametrem Serialize rozmowy, a nie za pomocą << lub >> operator CArchive.Jest to ważny fakt należy pamiętać, że CArchive>> konstrukcje operatora CObject w pamięci na podstawie CRuntimeClass informacje uprzednio zapisane w pliku przez przechowywanie archiwum. 

W związku z tym, czy używać CArchive<< i >> podmioty gospodarcze, w stosunku do telefonicznej Serialize, zależy, czy możesz muszą archiwum załadunku dynamicznie odtworzenie obiektu na podstawie poprzednio zapisanych CRuntimeClass informacji. Użycie Serialize funkcja w następujących przypadkach:

• Podczas deserializacji obiektu, wiesz dokładnie klasy obiektu wcześniej.

• Podczas deserializacji obiektu, masz już pamięć przydzielona dla niego.

Przestroga
Jeśli ładowany przy użyciu obiektu Serialize funkcji, muszą również być przechowywane obiektu za pomocą Serialize funkcji.Nie należy przechowywać za pomocą CArchive<< operator, a następnie przy użyciu obciążenia Serialize funkcji lub przechowywania za pomocą Serialize funkcja, a następnie załadować za pomocą CArchive>> operatora.

Poniższy przykład ilustruje przypadkach:

class CMyObject : public CObject
{
// ...Member functions
public:
   CMyObject() { }
   virtual void Serialize( CArchive& ar );

// Implementation
protected:
   DECLARE_SERIAL( CMyObject )
};


class COtherObject : public CObject
{
   // ...Member functions
public:
   COtherObject() { }
   virtual void Serialize( CArchive& ar );

// Implementation
protected:
   DECLARE_SERIAL( COtherObject )
};


class CCompoundObject : public CObject
{
   // ...Member functions
public:
   CCompoundObject();
   ~CCompoundObject();
   virtual void Serialize( CArchive& ar );

// Implementation
protected:
   CMyObject m_myob;    // Embedded object
   COtherObject* m_pOther;    // Object allocated in constructor
   CObject* m_pObDyn;    // Dynamically allocated object
   //..Other member data and implementation

   DECLARE_SERIAL( CCompoundObject )
};

IMPLEMENT_SERIAL(CMyObject,CObject,1)
IMPLEMENT_SERIAL(COtherObject,CObject,1)
IMPLEMENT_SERIAL(CCompoundObject,CObject,1)


CCompoundObject::CCompoundObject()
{
   m_pOther = new COtherObject; // Exact type known and object already  
            //allocated.
   m_pObDyn = NULL;    // Will be allocated in another member function 
            // if needed, could be a derived class object.
}

CCompoundObject::~CCompoundObject()
{
   delete m_pOther;
}

void CCompoundObject::Serialize( CArchive& ar )
{
   CObject::Serialize( ar );    // Always call base class Serialize.
   m_myob.Serialize( ar );    // Call Serialize on embedded member.
   m_pOther->Serialize( ar );    // Call Serialize on objects of known exact type. 

   // Serialize dynamic members and other raw data 
   if ( ar.IsStoring() )
   {
      ar << m_pObDyn;
      // Store other members
   }
   else
   {
      ar >> m_pObDyn; // Polymorphic reconstruction of persistent object  
      //load other members
   }
}

W skrócie, jeśli Twój serializować klasa definiuje osadzony CObject jako członek powinien nie używać CArchive<< i >> operatorów dla tego obiektu, ale powinna wywołać Serialize zamiast działać. Ponadto jeśli serializować klasy definiuje wskaźnik do CObject (lub pochodnymi obiektu CObject) jako członek, ale konstrukcje tego innego obiektu w jego własny Konstruktor można również zadzwonić pod Serialize.

Zobacz też

Koncepcje

Serializacja: serializacja obiektu