Stockage et chargement de CObjects via une archive

Le stockage et le chargement de CObject via une archive nécessite une attention particulière. Dans certains cas, vous devez appeler la fonction Serialize de l'objet, où l'objet CArchive est un paramètre de l'appel Serialize, plutôt que d'utiliser l'opérateur << ou >> de CArchive. Il est important de garder à l'esprit que l'opérateur CArchive>> construit le CObject en mémoire à partir des informations CRuntimeClass précédemment écrites dans le fichier par l'archive de stockage.

Par conséquent, si vous utilisez les opérateurs CArchive, <<, >> plutôt que d’appeler Serialize, cela dépend de si vous avez besoin de l’archive de chargement pour reconstruire dynamiquement l’objet en fonction des informations précédemment stockées CRuntimeClass. Utilisez la Serialize fonction dans les cas suivants :

• Lors de la désérialisation de l’objet, vous connaissez la classe exacte de l’objet au préalable.

• Lorsque de la désérialisation de l'objet, de la mémoire lui est déjà allouée.

L’exemple suivant illustre les cas suivants :

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 résumé, si votre classe sérialisable définit un CObject incorporé en tant que membre, vous ne devez pas utiliser les opérateurs CArchive<< et >> pour cet objet, mais vous devriez appeler plutôt la fonction Serialize. En outre, si votre classe sérialisable définit un pointeur vers un CObject (ou un objet dérivé de CObject) en tant que membre, mais construit cet autre objet dans son propre constructeur, vous devez également appeler Serialize.

Voir aussi

Sérialisation : sérialisation d’un objet