Speichern und Laden eines CObject per Archiv

Das Speichern und Laden von CObjects zu einem Archiv erfordert zusätzliche Überlegung. In bestimmten Fällen sollten Sie die Serialize-Funktion des Objekts aufrufen, in dem das CArchive-Objekt ein Parameter des Serialize - Aufrufs, im Gegensatz zur Verwendung des << oder >>-Operators CArchive. Der Tatsache wichtige erkennen ist, dass der Operator CArchiveCObject>> im Arbeitsspeicher auf CRuntimeClass basieren Informationen erstellt, die dem der Datei durch das Archiv speichernde geschrieben werden.

Daher ob Sie CArchive mit << und >>, Operatoren für das Aufrufen von Serialize, hängt davon ab, ob Sie das Ladenarchiv benötigen, um das Objekt auf Grundlage zuvor gespeicherte CRuntimeClass Informationen dynamisch zu rekonstruieren. Verwenden Sie die Funktion Serialize in den folgenden Fällen:

• Wenn Sie das Objekt deserialisieren, kennen Sie die exakte Klasse des Objekts zuvor.

• Wenn Sie das Objekt deserialisieren, verfügen Sie bereits den Arbeitsspeicher, der dafür zugeordnet ist.

Warnung

Wenn Sie das Objekt mit der Serialize-Funktion geladen, müssen Sie das Objekt mit der Serialize-Funktion auch speichern.Speichern Sie nicht mit dem Operator CArchive << und laden dann mit der Serialize-Funktion oder der Speicher mit der Serialize-Funktion und laden dann mit Operators CArchive >>.

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

Zusammenfassend wenn die Klasse CObjec serialisierbare eingebettetes t als Member definiert, sollte CArchive << und >> für Operatoren dieses Objekt nicht verwenden, sondern sollten die Serialize stattdessen Funktion aufrufen. Wenn Ihre serialisierbare Klasse einen Zeiger auf CObject (oder einem Objekt wird von CObject abgeleitet) als Member definiert, erstellt jedoch dieses anderen Objekt im eigenen Konstruktor, sollten Sie Serialize aufrufen.

Siehe auch

Konzepte

Serialisierung: Serialisieren eines Objekts