Armazenando e carregando CObjects por meio de um arquivo morto

Armazenar e carregar CObjects meio de um arquivo morto exigem consideração adicional. Em alguns casos, você deve chamar a função de Serialize do objeto, onde o objeto de CArchive é um parâmetro de chamada de Serialize , em vez de usar o operador de << ou de >> de CArchive. O fato importante a serem levadas em consideração é que o operador de CArchive>> constrói CObject na memória com base nas informações de CRuntimeClass gravada anteriormente para o arquivo do arquivo morto armazenando.

Em virtude disso, se você usar os operadores CArchive << e >>, chamar Serialize, depende de se você precisar do arquivo morto de carga para recriar o objeto dinamicamente com base nas informações de CRuntimeClass anteriormente armazenadas. Use a função de Serialize nos seguintes casos:

• A desserialização o objeto, você saberá a classe exata do objeto de antecipadamente.

• A desserialização o objeto, você já tiver a memória alocada para ela.

Aviso

Se você carregar o objeto usando a função de Serialize , você também deve armazenar o objeto usando a função de Serialize .Não armazene usando o operador de CArchive<< e não carregar com a função de Serialize , ou armazenar usando a função de Serialize carregar e usar o operador de CArchive >> .

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 CObject inserido como um 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 CObject (ou a 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.

Consulte também

Conceitos

Serialização: serializando um objeto