Almacenar y cargar objetos CObject a través de un archivo

El almacenamiento y la carga de CObjects a través de un archivo requiere una consideración adicional. En determinados casos, debe llamar a la función Serialize del objeto, donde el objeto CArchive es un parámetro de la llamada Serialize, en lugar de usar el operador << o >> del CArchive. El hecho importante que hay que tener en cuenta es que el operador CArchive del objeto >> operador construye el objeto CObject en memoria en función de la información de CRuntimeClass que el archivo de almacenamiento escribe previamente en el archivo.

Por lo tanto, si usa los CArchive<< operadores y >> , en lugar de llamar a Serialize, depende de si necesita el archivo de carga para reconstruir dinámicamente el objeto en función de la información almacenada CRuntimeClass previamente. Use la Serialize función en los casos siguientes:

• Al deserializar el objeto, conoce la clase exacta del objeto de antemano.

• Al deserializar el objeto, ya tiene memoria asignada para él.

Precaución

Si carga el objeto mediante la Serialize función , también debe almacenar el objeto mediante la Serialize función . No almacene usando el operador CArchive<< y luego cargue mediante la función Serialize, o almacene usando la función Serialize y luego cargue mediante el operador CArchive >>.

En el ejemplo siguiente se muestran los 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
   }
}

En resumen, si su clase serializable define un CObject incrustado como miembro, no debería usar los operadores CArchive y << para ese objeto; en su lugar, debería llamar a la función >>. Además, si la clase serializable define un puntero a un CObject (o un objeto derivado de CObject) como miembro, pero construye este otro objeto en su propio constructor, también debe llamar a Serialize.

Consulte también

Serialización: serialización de un objeto