L'enregistrement et le chargement CObjects via une archive
Le stockage et chargement de CObjects via une archive requiert une attention supplémentaire. Dans certains cas, vous devez appeler la fonction Serialize de l'objet, où l'objet CArchive est un paramètre de l'appel Serialize, par opposition à utiliser l'opérateur << ou >> de CArchive. Le fait qu'il est important de prendre en compte est que l'opérateur CArchive>> construit le CObject en mémoire en fonction des informations CRuntimeClass précédemment écrites dans le fichier d'archive de journalisation.
Par conséquent, si vous utilisez les opérateurs CArchive << et >>, plutôt qu'appeler Serialize, dépend de si vous avez besoin que l'archive de chargement reconstruise dynamiquement l'objet selon les informations CRuntimeClass préalablement stockées. Utilisez la fonction Serialize dans les cas suivants :
En désérialisant l'objet, vous connaissez la classe exacte de l'objet au préalable.
En désérialisant l'objet, vous avez déjà de la mémoire allouée pour ce dernier.
Avertissement
Si vous chargez l'objet à l'aide de la fonction Serialize, vous devez également stocker l'objet à l'aide de la fonction Serialize.Ne stockez pas en utilisant l'opérateur CArchive<< puis en chargeant en utilisant la fonction Serialize, ou à l'aide de la fonction Serialize puis en chargeant en utilisant l'opérateur CArchive >>.
L'exemple de code suivant illustre le 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 CObject incorporé comme membre, vous ne devez pas utiliser CArchive << et les opérateurs >> pour cet objet, mais vous devez appeler la fonction Serialize à la 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 l'autre objet dans son propre constructeur, vous devez aussi appeler Serialize.