Stockage et chargement de CObjects via une archive

Le stockage et le chargement CObjectde s via une archive nécessitent une considération supplémentaire. Dans certains cas, vous devez appeler la Serialize fonction de l’objet, où l’objet CArchive est un paramètre de l’appelSerialize, par opposition à l’utilisation de l’opérateur ou >> du <<CArchive. Le fait important à garder à l’esprit est que l’opérateur CArchive>> construit la CObject mémoire en CRuntimeClass fonction des informations précédemment écrites dans le fichier par l’archive de stockage.

Par conséquent, si vous utilisez les CArchive<< opérateurs et >> opérateurs, plutôt que d’appeler Serialize, dépend 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.

• Lors de la désérialisation de l’objet, vous disposez déjà de la mémoire allouée.

Attention

Si vous chargez l’objet à l’aide de la Serialize fonction, vous devez également stocker l’objet à l’aide de la Serialize fonction. Ne stockez pas à l’aide de l’opérateur CArchive<< , puis chargez à l’aide de la Serialize fonction, ou stockez à l’aide de la Serialize fonction, puis chargez l’opérateur CArchive >> .

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 incorporé CObject en tant que membre, vous ne devez pas utiliser les opérateurs et >> les CArchive<< opérateurs de cet objet, mais appeler la fonction à la Serialize place. 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