Armazenar e carregando CObjects via um arquivo morto

Armazenar e carregando CObjects por meio de um arquivo requer considerações extra.Em determinados casos, você deve chamar o Serialize função do objeto, onde o CArchive objeto é um parâmetro do Serialize chamada, em oposição a usando o << ou >> operador do CArchive.O fato importante ter em mente é que o CArchive>> construções de operador de CObject na memória com base em CRuntimeClass informações anteriormente gravadas para o arquivo pelo arquivamento armazenando.

Portanto, se você usar o CArchive<< e >> operadores versus chamada Serialize, depende se você precisa arquivamento carregar dinamicamente reconstruir o objeto baseado em armazenados anteriormente CRuntimeClass informações.Use o Serialize função nos seguintes casos:

• Ao desserializar o objeto, você sabe a classe exata do objeto antecipadamente.

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

Cuidado
Se você carregar o objeto usando o Serialize função, você também deve armazenar o objeto usando o Serialize função.Não armazenar usando o CArchive<< operador e, em seguida, carregar usando o Serialize funcionar ou armazenar usando o Serialize de função e carregar usando CArchive >> operador.

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 sua classe serializável define um incorporado CObject como um membro, você deve não usar o CArchive<< e >> operadores para o objeto, mas deve chamar o Serialize função 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 construções este outro objeto no seu próprio construtor, você deve também chamar Serialize.

Consulte também

Conceitos

Serialização: Serializar um objeto