Armazenando e carregando CObjects através de um arquivo

Armazenar e carregar CObjects através de um arquivo requer consideração extra. Em certos casos, deve chamar a função Serialize do objeto, onde o objeto CArchive é um parâmetro da chamada Serialize, em vez de usar o operador << ou >> do CArchive. O fato importante a ter em mente é que o CArchive>> operador constrói o CObject na memória com base em CRuntimeClass informações previamente gravadas no arquivo pelo arquivo de armazenamento.

Portanto, se você usa os CArchive<< operadores e >> versus chamar Serialize, depende se você precisa do arquivo de carregamento para reconstruir dinamicamente o objeto com base em informações armazenadas CRuntimeClass anteriormente. Use a Serialize função nos seguintes casos:

• Ao desserializar o objeto, você sabe a classe exata do objeto de antemão.

• Ao desserializar o objeto, você já tem memória alocada para ele.

O exemplo a seguir ilustra os casos:

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

Em resumo, se a sua classe serializável define um incorporado CObject como membro, você não deve usar os operadores CArchive<< e >> para esse objeto, mas deve chamar a função Serialize em vez disso. Além disso, se sua classe serializável define um ponteiro para um CObject (ou um objeto derivado de CObject) como um membro, mas constrói esse outro objeto em seu próprio construtor, você também deve chamar Serialize.

Ver também

Serialização: Serializando um objeto