Speichern und Laden von CObjects über ein Archiv

Das Speichern und Laden von CObject ü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, die zu beachten ist, ist, dass der CArchive>> Operator das CObject im Speicher basierend auf CRuntimeClass Informationen konstruiert, die zuvor durch das Speichern des Archivs in die Datei geschrieben wurden.

Daher hängt es davon ab, ob Sie die Operatoren CArchive<< und >> verwenden oder Serialize aufrufen, je nachdem, ob Sie das Ladenarchiv benötigen, um das Objekt auf der Grundlage zuvor gespeicherter CRuntimeClass 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 ist bereits Speicherplatz dafür reserviert.

Vorsicht

Wenn Sie das Objekt mithilfe der Serialize Funktion laden, müssen Sie das Objekt auch mithilfe der Serialize Funktion speichern. Speichern Sie nicht mit dem CArchive<< Operator und laden dann mit der Serialize Funktion, oder speichern Sie mit der Serialize Funktion und laden dann mit dem 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 ein von CObject abgeleitetes Objekt) als Element definiert, aber dieses andere Objekt in ihrem eigenen Konstruktor erstellt, sollten Sie auch Serialize aufrufen.

Siehe auch

Serialisierung: Serialisieren eines Objekts