CObjects archiviante e di carico tramite un archivio
Archiviare e CObjectcaricare gli oggetti mediante un archivio richiedono una considerazione aggiuntiva.In alcuni casi, è consigliabile chiamare la funzione di Serialize oggetto, in cui l'oggetto di CArchive è un parametro della chiamata di Serialize , anziché utilizzando l'operatore di >> o di << di CArchive.Il fatto importante tenere presente che l'operatore di CArchive>> costruisce CObject in memoria in base alle informazioni di CRuntimeClass precedentemente scritte nel file dall'archivio archiviante.
Pertanto, se si utilizza CArchive<< e operatori di >> , e chiamare Serialize, varia a seconda che è necessario disporre dell'archivio di caricamento ricostruire dinamicamente l'oggetto in base alle informazioni memorizzate in precedenza di CRuntimeClass .Utilizzare la funzione di Serialize nei seguenti casi:
In deserializzare l'oggetto, conosce in anticipo la classe esatta dell'oggetto.
In deserializzare l'oggetto, si dispone già di memoria allocata per.
Attenzione |
---|
Se si carica l'oggetto utilizzando la funzione di Serialize , è inoltre necessario archiviare l'oggetto utilizzando la funzione di Serialize .Non memorizzare utilizzando l'operatore di CArchive<< quindi non caricare utilizzando la funzione di Serialize , archiviazione o utilizzando la funzione di Serialize quindi non caricare utilizzando l'operatore di CArchive >> . |
Nell'esempio seguente vengono illustrati i casi:
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
}
}
In breve, se la classe serializzabile definisce CObjecincorporato t come membro, non è necessario utilizzare CArchive<< e gli operatori di >> per tale oggetto, ma è necessario chiamare la funzione di Serialize anziché.Inoltre, se la classe serializzabile definisce un puntatore a CObject (o a un oggetto derivato da CObject) come membro, ma costruisce questo altro oggetto nel relativo costruttore, è inoltre necessario chiamare Serialize.