Memorizzazione e caricamento di CObjects tramite un archivio

Archiviare e CObjectcaricare o tramite un archivio richiedono una considerazione aggiuntiva. In alcuni casi, è consigliabile chiamare la funzione di Serialize oggetto, in cui l'oggetto di CArchive è un parametro della chiamata di Serialize, in contrapposizione a utilizzare l'operatore di >> o di << di CArchive. Il fatto importante tenere presente che l'operatore di CArchive >> costruisce CObject in memoria in base alle informazioni di CRuntimeClass precedentemente scritte nel file dall'archivio archiviando.

Pertanto, se si utilizza CArchive << e operatori di >>, rispetto a chiamare Serialize, varia a seconda che è necessario disporre dell'archivio di caricamento di ricostruirla dinamicamente l'oggetto di informazioni memorizzate in precedenza di CRuntimeClass. Utilizzare la funzione di Serialize nei seguenti casi:

• In deserializzare l'oggetto, conosce in anticipo la classe esatta dell'oggetto.

• In deserializzare l'oggetto, si dispone già di memoria allocata per.

Avviso

Se si carica l'oggetto utilizzando la funzione di Serialize, è necessario anche possibile memorizzare l'oggetto utilizzando la funzione di Serialize.Non memorizzare utilizzando l'operatore di CArchive << quindi non caricare utilizzando la funzione di Serialize, o dell'archivio utilizzando la funzione di Serialize quindi non caricare utilizzando l'operatore di CArchive >>.

Nell'esempio seguente vengono illustrati i casi:

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

In breve, se la classe definisce serializzabile CObjecincorporato t come membro, non è necessario utilizzare CArchive << e gli operatori di >> per tale oggetto, ma è necessario chiamare la funzione di Serialize invece. Inoltre, se la classe serializzabile definisce un puntatore a CObject (o a un oggetto derivato da CObject) come membro, ma crea questo altro oggetto nel relativo costruttore, è necessario chiamare anche Serialize.

Vedere anche

Concetti

Serializzazione: serializzazione di un oggetto