Almacenar y cargando CObjects mediante un archivo

Almacenar y cargar s para CObjectmediante un archivo requiere la consideración adicional.En algunos casos, debe llamar a la función de Serialize de objeto, donde es un parámetro el objeto de CArchive de llamada de Serialize , en comparación con el operador de << o de >> de CArchive.El hecho importante a tener en cuenta es que el operador de CArchive>> construye CObject en memoria basándose en la información de CRuntimeClass escrita anteriormente al archivo por el archivo que almacena.

Por consiguiente, si utiliza CArchive<< y operadores de >> , para llamar a Serialize, depende de si necesita el archivo de carga volver a crear dinámicamente el objeto basándose en la información anteriormente almacenada de CRuntimeClass .Utilice la función de Serialize en los casos siguientes:

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

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

Precaución
Si carga el objeto mediante la función de Serialize , también debe almacenar el objeto mediante la función de Serialize .No almacene mediante el operador de CArchive<< y no cargue utilizando la función de Serialize , o el almacén mediante la función de Serialize y no cargue utilizando el operador de CArchive >> .

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 la clase serializable define t incrustada de CObjeccomo miembro, no debe utilizar CArchive<< y operadores de >> para ese objeto, pero debe llamar a la función de Serialize en su lugar.Además, si la clase serializable define un puntero a CObject (o a un objeto derivado de CObject) como miembro, pero construye este otro objeto en un constructor, también debe llamar a Serialize.

Vea también

Conceptos

Serialización: Serialización de un objeto