L'enregistrement et le chargement CObjects via une archive

L'enregistrement et le chargement CObjects via une archive requiert la considération supplémentaire.Dans certains cas, vous devez appeler la fonction d' Serialize de l'objet, où l'objet d' CArchive est un paramètre de l'appel d' Serialize , par opposition à utiliser l'opérateur de << ou de >> d' CArchive.Il est important à prendre en considération est que l'opérateur d' CArchive>> construit CObject dans la mémoire en fonction de les informations d' CRuntimeClass précédemment écrites dans le fichier par l'archive s'stockage.

Par conséquent, si vous utilisez CArchive<< et les opérateurs de >> , et appeler Serialize, dépend de si vous avez besoin de l'archive de chargement pour régénérer dynamiquement l'objet selon les informations stockées précédemment d' CRuntimeClass .Utilisez la fonction d' Serialize dans les cas suivants :

• Désérialiser l'objet, vous connaissez la classe exacte de l'objet à l'avance.

• Désérialiser l'objet, vous avez déjà la mémoire allouée pour celui-ci.

Attention
Si vous chargez l'objet à l'aide de la fonction d' Serialize , vous devez également enregistrer l'objet à l'aide de la fonction d' Serialize .Ne stockez pas l'aide de l'opérateur d' CArchive<< puis chargez ne pas à l'aide de la fonction d' Serialize , ou le magasin à l'aide de la fonction d' Serialize et chargez ne pas utiliser ensuite l'opérateur de CArchive >> .

L'exemple suivant illustre les cas :

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

Voir aussi

Concepts

Sérialisation : sérialiser un objet