Speichern und Laden eines CObject per Archiv

Das Speichern und Laden CObjectvon S über ein Archiv erfordert zusätzliche Überlegungen. In bestimmten Fällen sollten Sie die Serialize Funktion des Objekts aufrufen, wobei das CArchive Objekt ein Parameter des Serialize Aufrufs ist, im Gegensatz zur Verwendung des << Oder >> Operators der CArchive. Die wichtige Tatsache, dass der CArchive>> Operator den CObject Speicher basierend auf CRuntimeClass Informationen erstellt, die zuvor durch das Speichern des Archivs in die Datei geschrieben wurden.

Daher hängt davon ab, ob Sie das<< >> CArchiveLadenarchiv verwenden, um das Objekt basierend auf zuvor gespeicherten SerializeCRuntimeClass Informationen dynamisch zu rekonstruieren. Verwenden Sie die Serialize Funktion in den folgenden Fällen:

• Beim Deserialisieren des Objekts kennen Sie die genaue Klasse des Objekts vorher.

• Beim Deserialisieren des Objekts haben Sie bereits Arbeitsspeicher zugewiesen.

Achtung

Wenn Sie das Objekt mithilfe der Serialize Funktion laden, müssen Sie das Objekt auch mithilfe der Serialize Funktion speichern. Speichern CArchive<< Sie den Operator nicht, und laden Sie dann die Serialize Funktion, oder speichern Serialize Sie die Funktion, und laden Sie dann den CArchive >> Operator.

Das folgende Beispiel veranschaulicht die Fälle:

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
   }
}

Wenn Ihre serialisierbare Klasse eine eingebettete CObject Klasse als Element definiert, sollten Sie nicht die CArchive<< Operatoren und >> Operatoren für dieses Objekt verwenden, sondern stattdessen die Serialize Funktion aufrufen. Wenn ihre serialisierbare Klasse einen Zeiger auf ein CObject (oder von ) abgeleitetes CObjectObjekt als Element definiert, aber dieses andere Objekt in seinem eigenen Konstruktor erstellt, sollten Sie auch aufrufen Serialize.

Siehe auch

Serialisierung: Serialisieren eines Objekts