CArchive-klasse

Hiermee kunt u een complex netwerk van objecten opslaan in een permanente binaire vorm (meestal schijfopslag) die behouden blijft nadat deze objecten zijn verwijderd.

Syntaxis

class CArchive

Leden

Openbare constructors

Naam	Beschrijving
CArchive::CArchive	Hiermee maakt u een CArchive-object.

Openbare methoden

Naam	Beschrijving
CArchive::Abort	Hiermee sluit u een archief zonder een uitzondering te genereren.
CArchive::Close	Verwijdert ongeschreven gegevens en verbreekt de verbinding met de CFile.
CArchive::Flush	Verwijdert ongeschreven gegevens uit de archiefbuffer.
CArchive::GetFile	Hiermee haalt u de CFile objectpointer voor dit archief op.
CArchive::GetObjectSchema	Aangeroepen vanuit de Serialize functie om te bepalen welke versie van het object wordt gedeserialiseerd.
CArchive::IsBufferEmpty	Bepaalt of de buffer is geleegd tijdens een Ontvangstproces van Windows Sockets.
CArchive::IsLoading	Bepaalt of het archief wordt geladen.
CArchive::IsStoring	Bepaalt of het archief wordt opgeslagen.
CArchive::MapObject	Hiermee plaatst u objecten in de kaart die niet naar het bestand zijn geserialiseerd, maar die beschikbaar zijn voor subobjecten waarnaar moet worden verwezen.
CArchive::Read	Leest onbewerkte bytes.
CArchive::ReadClass	Leest een klassereferentie die eerder is opgeslagen met WriteClass.
CArchive::ReadObject	Roept de functie van Serialize een object aan voor het laden.
CArchive::ReadString	Leest één regel tekst.
CArchive::SerializeClass	Leest of schrijft de klasseverwijzing naar het CArchive object, afhankelijk van de richting van de CArchive.
CArchive::SetLoadParams	Hiermee stelt u de grootte in waarop de loadmatrix groeit. Moet worden aangeroepen voordat een object wordt geladen of vóór MapObject of ReadObject wordt aangeroepen.
CArchive::SetObjectSchema	Hiermee stelt u het objectschema in dat is opgeslagen in het archiefobject.
CArchive::SetStoreParams	Hiermee stelt u de grootte van de hashtabel en de blokgrootte van de kaart in die wordt gebruikt om unieke objecten te identificeren tijdens het serialisatieproces.
CArchive::Write	Schrijft onbewerkte bytes.
CArchive::WriteClass	Hiermee schrijft u een verwijzing naar de naar de CRuntimeClassCArchive.
CArchive::WriteObject	Roept de functie van Serialize een object aan voor het opslaan.
CArchive::WriteString	Hiermee schrijft u één regel tekst.

Openbare operators

Naam	Beschrijving
CArchive::operator <<	Hiermee worden objecten en primitieve typen opgeslagen in het archief.
CArchive::operator >>	Hiermee worden objecten en primitieve typen uit het archief geladen.

Leden van openbare gegevens

Naam	Beschrijving
CArchive::m_pDocument

Opmerkingen

CArchive heeft geen basisklasse.

Later kunt u de objecten laden vanuit permanente opslag, waarbij u ze opnieuw in het geheugen opstelt. Dit proces voor het persistent maken van gegevens wordt 'serialisatie' genoemd.

U kunt een archiefobject beschouwen als een soort binaire stroom. Net als een invoer-/uitvoerstroom wordt een archief gekoppeld aan een bestand en kan het gebufferde schrijven en lezen van gegevens naar en van opslag worden toegestaan. Een invoer-/uitvoerstroom verwerkt reeksen ASCII-tekens, maar een archief verwerkt binaire objectgegevens in een efficiënte, niet-redundante indeling.

U moet een CFile object maken voordat u een CArchive object kunt maken. Bovendien moet u ervoor zorgen dat de laad-/archiefstatus van het archief compatibel is met de geopende modus van het bestand. U bent beperkt tot één actief archief per bestand.

Wanneer u een CArchive object maakt, koppelt u het aan een object van klasse CFile (of een afgeleide klasse) dat een geopend bestand vertegenwoordigt. U geeft ook op of het archief wordt gebruikt voor het laden of opslaan. Een CArchive object kan niet alleen primitieve typen verwerken, maar ook objecten van CObject-afgeleide klassen die zijn ontworpen voor serialisatie. Een serialiseerbare klasse heeft meestal een Serialize lidfunctie en gebruikt meestal de DECLARE_SERIAL en IMPLEMENT_SERIAL macro's, zoals beschreven onder klasse CObject.

De operators voor overbelaste extractie (>>) en invoeging (<<) zijn handige archiefprogrammeerinterfaces die zowel primitieve typen als CObject-afgeleide klassen ondersteunen.

CArchive ondersteunt ook programmeren met de MFC Windows Sockets-klassen CSocket en CSocketFile. De IsBufferEmpty lidfunctie ondersteunt dat gebruik.

Zie de artikelen CArchive en Windows Sockets: Sockets gebruiken met archieven voor meer informatie.

Overnamehiërarchie

CArchive

Behoeften

koptekst:afx.h

CArchive::Abort

Roep deze functie aan om het archief te sluiten zonder een uitzondering te genereren.

void Abort ();

Opmerkingen

De CArchive destructor roept normaal gesproken Closeaan, waardoor alle gegevens die niet zijn opgeslagen in het bijbehorende CFile object worden leeggemaakt. Dit kan uitzonderingen veroorzaken.

Bij het ondervangen van deze uitzonderingen is het een goed idee om het object te gebruiken Abort, zodat het CArchive object geen verdere uitzonderingen veroorzaakt. Bij het afhandelen van uitzonderingen wordt er geen uitzondering op fouten gegenereerd, CArchive::Abort omdat in tegenstelling tot CArchive::Closefouten Abort fouten worden genegeerd.

Als u new het CArchive object aan de heap hebt toegewezen, moet u het verwijderen nadat u het bestand hebt gesloten.

Voorbeeld

Zie het voorbeeld voor CArchive::WriteClass.

CArchive::CArchive

Hiermee maakt u een CArchive object en geeft u op of het wordt gebruikt voor het laden of opslaan van objecten.

CArchive(
    CFile* pFile,
    UINT nMode,
    int nBufSize = 4096,
    void* lpBuf = NULL);

Parameterwaarden

pFile
Een aanwijzer naar het CFile object dat de ultieme bron of bestemming van de permanente gegevens is.

nMode
Een vlag die aangeeft of objecten worden geladen van of opgeslagen in het archief. De nMode parameter moet een van de volgende waarden hebben:

• CArchive::load Laadt gegevens uit het archief. Hiervoor is alleen CFile leesmachtiging vereist.

• CArchive::store Hiermee worden gegevens opgeslagen in het archief. Hiervoor is schrijfmachtiging vereist CFile .

• CArchive::bNoFlushOnDelete Hiermee voorkomt u dat het archief automatisch wordt aangeroepen Flush wanneer de archiefdestructor wordt aangeroepen. Als u deze vlag instelt, bent u verantwoordelijk voor het expliciet aanroepen voordat de destructor wordt aangeroepen Close . Als u dat niet doet, zijn uw gegevens beschadigd.

nBufSize
Een geheel getal dat de grootte van de interne bestandsbuffer in bytes aangeeft. Houd er rekening mee dat de standaardbuffergrootte 4096 bytes is. Als u regelmatig grote objecten archiveert, verbetert u de prestaties als u een grotere buffergrootte gebruikt die een veelvoud is van de bestandsgrootte.

lpBuf
Een optionele aanwijzer naar een door de gebruiker geleverde buffer van grootte nBufSize. Als u deze parameter niet opgeeft, wijst het archief een buffer toe vanuit de lokale heap en maakt het vrij wanneer het object wordt vernietigd. Het archief maakt geen door de gebruiker geleverde buffer vrij.

Opmerkingen

U kunt deze specificatie niet wijzigen nadat u het archief hebt gemaakt.

U mag bewerkingen niet gebruiken CFile om de status van het bestand te wijzigen totdat u het archief hebt gesloten. Een dergelijke bewerking zal de integriteit van het archief beschadigen. U kunt de positie van de bestandsaanwijzer op elk gewenst moment tijdens de serialisatie openen door het bestandsobject van het archief te verkrijgen van de GetFile lidfunctie en vervolgens de CFile::GetPosition functie te gebruiken. U moet aanroepen CArchive::Flush voordat u de positie van de bestandsaanwijzer verkrijgt.

Voorbeeld

CFile file;
TCHAR szBuf[512];
if (!file.Open(_T("CArchive__test__file.txt"),
               CFile::modeCreate | CFile::modeWrite))
{
#ifdef _DEBUG
   AFXDUMP(_T("Unable to open file\n"));
   exit(1);
#endif
}
CArchive ar(&file, CArchive::store, 512, szBuf);

CArchive::Close

Hiermee worden alle resterende gegevens in de buffer leeggemaakt, het archief gesloten en wordt het archief losgekoppeld van het bestand.

void Close();

Opmerkingen

Er zijn geen verdere bewerkingen op het archief toegestaan. Nadat u een archief hebt gesloten, kunt u een ander archief voor hetzelfde bestand maken of kunt u het bestand sluiten.

De lidfunctie Close zorgt ervoor dat alle gegevens van het archief naar het bestand worden overgebracht en dat het archief niet beschikbaar is. Als u de overdracht van het bestand naar het opslagmedium wilt voltooien, moet u eerst het object gebruiken CFile::Close en vervolgens CFile vernietigen.

Voorbeeld

Zie het voorbeeld voor CArchive::WriteString.

CArchive::Flush

Dwingt eventuele gegevens die in de archiefbuffer blijven, naar het bestand te worden geschreven.

void Flush();

Opmerkingen

De lidfunctie Flush zorgt ervoor dat alle gegevens vanuit het archief naar het bestand worden overgebracht. U moet aanroepen CFile::Close om de overdracht van het bestand naar het opslagmedium te voltooien.

Voorbeeld

CFile myFile(_T("CArchive__test__file.txt"),
             CFile::modeCreate | CFile::modeWrite);
CArchive ar(&myFile, CArchive::store);

// Write a string to the archive.
ar.WriteString(_T("My string."));

// Flush all of the data to the file.
ar.Flush();

CArchive::GetFile

Hiermee haalt u de CFile objectpointer voor dit archief op.

CFile* GetFile() const;

Retourwaarde

Een constante aanwijzer naar het CFile object dat wordt gebruikt.

Opmerkingen

U moet het archief leegmaken voordat u het gebruikt GetFile.

Voorbeeld

const CFile *fp = ar.GetFile();

CArchive::GetObjectSchema

Roep deze functie aan vanuit de Serialize functie om de versie te bepalen van het object dat momenteel wordt gedeserialiseerd.

UINT GetObjectSchema();

Retourwaarde

Tijdens de deserialisatie wordt de versie van het object gelezen.

Opmerkingen

Het aanroepen van deze functie is alleen geldig wanneer het CArchive object wordt geladen ( CArchive::IsLoading retourneert niet-nul). Dit moet de eerste aanroep in de Serialize functie zijn en slechts één keer worden aangeroepen. Een retourwaarde van (UINT)-1 geeft aan dat het versienummer onbekend is.

Een CObject-afgeleide klasse kan gecombineerd (met bitwise 'or' (VERSIONABLE_SCHEMA)) gebruiken met de schemaversie zelf (in de | macro) om een 'versiebaar object' te maken, dat wil gezegdIMPLEMENT_SERIAL, een object waarvan Serialize de lidfunctie meerdere versies kan lezen. De standaardframeworkfunctionaliteit (zonder VERSIONABLE_SCHEMA) is het genereren van een uitzondering wanneer de versie niet overeenkomt.

Voorbeeld

IMPLEMENT_SERIAL(CSchemaObject, CObject, VERSIONABLE_SCHEMA | 1)

void CSchemaObject::Serialize(CArchive &ar)
{
   CObject::Serialize(ar);

   if (ar.IsLoading())
   {
      int nVersion = ar.GetObjectSchema();

      switch (nVersion)
      {
      case 0:
         // read in previous version of
         // this object
         break;
      case 1:
         // read in current version of
         // this object
         break;
      default:
         // report unknown version of
         // this object
         break;
      }
   }
   else
   {
      // Normal storing code goes here
   }
}

CArchive::IsBufferEmpty

Roep deze lidfunctie aan om te bepalen of de interne buffer van het archiefobject leeg is.

BOOL IsBufferEmpty() const;

Retourwaarde

Niet-nul als de buffer van het archief leeg is; anders 0.

Opmerkingen

Deze functie wordt geleverd ter ondersteuning van programmeren met de MFC Windows Sockets-klasse CSocketFile. U hoeft deze niet te gebruiken voor een archief dat is gekoppeld aan een CFile object.

De reden voor het gebruik IsBufferEmpty van een archief dat is gekoppeld aan een CSocketFile object, is dat de buffer van het archief meer dan één bericht of record kan bevatten. Nadat u één bericht hebt ontvangen, moet u een lus beheren IsBufferEmpty die gegevens blijft ontvangen totdat de buffer leeg is. Zie de Receive lidfunctie van klasse CAsyncSocketvoor meer informatie, die laat zien hoe u deze kunt gebruiken IsBufferEmpty.

Zie Windows Sockets: Sockets gebruiken met archieven voor meer informatie.

CArchive::IsLoading

Bepaalt of het archief gegevens laadt.

BOOL IsLoading() const;

Retourwaarde

Niet-nul als het archief momenteel wordt gebruikt voor het laden; anders 0.

Opmerkingen

Deze lidfunctie wordt aangeroepen door de Serialize functies van de gearchiveerde klassen.

Voorbeeld

int i = 0;
if (ar.IsLoading())
   ar >> i;
else
   ar << i;

CArchive::IsStoring

Bepaalt of het archief gegevens opslaat.

BOOL IsStoring() const;

Retourwaarde

Niet-nul als het archief momenteel wordt gebruikt voor opslag; anders 0.

Opmerkingen

Deze lidfunctie wordt aangeroepen door de Serialize functies van de gearchiveerde klassen.

Als de status van een archief niet-nul is, IsStoring is de IsLoading status 0 en omgekeerd.

Voorbeeld

int i = 0;
if (ar.IsStoring())
   ar << i;
else
   ar >> i;

CArchive::MapObject

Roep deze lidfunctie aan om objecten in de kaart te plaatsen die niet echt naar het bestand zijn geserialiseerd, maar die beschikbaar zijn voor subobjecten waarnaar kan worden verwezen.

void MapObject(const CObject* pOb);

Parameterwaarden

pOb
Een constante aanwijzer naar het object dat wordt opgeslagen.

Opmerkingen

U kunt bijvoorbeeld een document niet serialiseren, maar de items die deel uitmaken van het document serialiseren. Door aan te roepen MapObject, staat u deze items of subobjecten toe om naar het document te verwijzen. Bovendien kunnen geserialiseerde subitems de m_pDocument backpointer serialiseren.

U kunt aanroepen MapObject wanneer u het object opslaat en laadt CArchive . MapObject voegt het opgegeven object toe aan de interne gegevensstructuren die door het CArchive object worden onderhouden tijdens serialisatie en deserialisatie, maar in tegenstelling tot ReadObject en WriteObject, wordt het object niet geserialiseerd.

Voorbeeld

//MyDocument.h
class CMyDocument : public CDocument
{
public:
   DECLARE_SERIAL(CMyDocument)

   CObList m_listOfSubItems;

   virtual void Serialize(CArchive &ar);
};

 

//MyDocument.cpp
IMPLEMENT_SERIAL(CMyDocument, CDocument, 1)

void CMyDocument::Serialize(CArchive& ar)
{
   CDocument::Serialize(ar);

   if (ar.IsStoring())
   {
      // TODO: add storing code here
   }
   else
   {
      // TODO: add loading code here
   }

   ar.MapObject(this);

   //serialize the subitems in the document;
   //they will be able to serialize their m_pDoc
   //back pointer
   m_listOfSubItems.Serialize(ar);
}

 

//SubItem.h
class CSubItem : public CObject
{
   DECLARE_SERIAL(CSubItem)
   CSubItem() : m_i(0){};

public:
   CSubItem(CMyDocument *pDoc)
   {
      m_pDoc = pDoc;
   }

   // back pointer to owning document
   CMyDocument *m_pDoc;
   WORD m_i; // other item data

   virtual void Serialize(CArchive &ar);
};

 

//SubItem.cpp
IMPLEMENT_SERIAL(CSubItem, CObject, 1);

void CSubItem::Serialize(CArchive &ar)

{
   if (ar.IsStoring())
   {
      // will serialize a reference
      // to the "mapped" document pointer
      ar << (CObject *)m_pDoc;
      ar << m_i;
   }
   else
   {
      // Will load a reference to
      // the "mapped" document pointer
      ar >> (CObject *&)m_pDoc;
      ar >> m_i;
   }
}

CArchive::m_pDocument

NULL Deze aanwijzer CDocument kan standaard worden ingesteld op alles wat de gebruiker van het CArchive exemplaar wil.

CDocument* m_pDocument;

Opmerkingen

Een veelvoorkomend gebruik van deze aanwijzer is om aanvullende informatie over het serialisatieproces over te brengen op alle objecten die worden geserialiseerd. Dit wordt bereikt door de aanwijzer te initialiseren met het document (een CDocument-afgeleide klasse) die wordt geserialiseerd, zodat objecten in het document zo nodig toegang hebben tot het document. Deze aanwijzer wordt ook gebruikt door COleClientItem objecten tijdens serialisatie.

Het framework wordt ingesteld m_pDocument op het document dat wordt geserialiseerd wanneer een gebruiker een opdracht Bestand openen of Opslaan uitgeeft. Als u een OLE-containerdocument (Object Linking and Embedding) serialiseert om andere redenen dan Bestand openen of Opslaan, moet u expliciet instellen m_pDocument. U doet dit bijvoorbeeld wanneer u een containerdocument serialiseert naar het Klembord.

Voorbeeld

CFile myFile(_T("My__test__file.dat"),
             CFile::modeCreate | CFile::modeWrite);
CArchive ar(&myFile, CArchive::store);
CMyDocument mydoc;
ar.m_pDocument = &mydoc;

// Serialize the document to the archive.
if (ar.m_pDocument != NULL)
   ar.m_pDocument->Serialize(ar);

CArchive::operator <<

Slaat het aangegeven object of primitief type op in het archief.

friend CArchive& operator<<(
    CArchive& ar,
    const CObject* pOb);

throw(
    CArchiveException*,
    CFileException*);

CArchive& AFXAPI operator<<(
    CArchive& ar,
    const RECT& rect);

CArchive& AFXAPI operator<<(
    CArchive& ar,
    POINT point);

CArchive& AFXAPI operator<<(
    CArchive& ar,
    SIZE size);

template<typename BaseType,
    class StringTraits> CArchive& operator<<(
    const ATL::CStringT<BaseType,
    StringTraits>& str);

CArchive& operator<<(BYTE by);
CArchive& operator<<(WORD w);
CArchive& operator<<(LONG l);
CArchive& operator<<(DWORD dw);
CArchive& operator<<(float f);
CArchive& operator<<(double d);
CArchive& operator<<(int i);
CArchive& operator<<(short w);
CArchive& operator<<(char ch);
CArchive& operator<<(wchar_t ch);
CArchive& operator<<(unsigned u);
CArchive& operator<<(bool b);
CArchive& operator<<(ULONGLONG dwdw);
CArchive& operator<<(LONGLONG dwdw);

Retourwaarde

Een CArchive verwijzing die meerdere invoegoperators op één regel mogelijk maakt.

Opmerkingen

De laatste twee versies hierboven zijn specifiek bedoeld voor het opslaan van 64-bits gehele getallen.

Als u de IMPLEMENT_SERIAL macro in uw klasse-implementatie hebt gebruikt, wordt de invoegoperator overbelast voor CObject aanroepen van de beveiligde WriteObject. Met deze functie wordt op zijn beurt de Serialize functie van de klasse aangeroepen.

De CStringT invoegoperator (<<) ondersteunt diagnostische dumping en opslag in een archief.

Voorbeelden

In dit voorbeeld ziet u het gebruik van de CArchive invoegoperator << met de int en long typen.

long l = 5;
int i = 10;
if (ar.IsStoring())
   ar << l << i;

In dit voorbeeld ziet u het gebruik van de CArchive invoegoperator << met het CStringT type.

CString s("abc");
ar << s; // Prints the value (abc)

CArchive::operator >>

Laadt het aangegeven object of primitieve type uit het archief.

friend CArchive& operator>>(
    CArchive& ar,
    CObject *& pOb);

throw(
    CArchiveException*,
    CFileException*,
    CMemoryException*);

friend CArchive& operator>>(
    CArchive& ar,
    const CObject *& pOb);

throw(
    CArchiveException*,
    CFileException*,
    CMemoryException*);

CArchive& AFXAPI operator>>(
    CArchive& ar,
    const RECT& rect);

CArchive& AFXAPI operator>>(
    CArchive& ar,
    POINT point);

CArchive& AFXAPI operator>>(
    CArchive& ar,
    SIZE size);

template<typename BaseType,
    class StringTraits> CArchive& operator>>(
    ATL::CStringT<BaseType,
    StringTraits>& str);

CArchive& operator>>(BYTE& by);
CArchive& operator>>(WORD& w);
CArchive& operator>>(int& i);
CArchive& operator>>(LONG& l);
CArchive& operator>>(DWORD& dw);
CArchive& operator>>(float& f);
CArchive& operator>>(double& d);
CArchive& operator>>(short& w);
CArchive& operator>>(char& ch);
CArchive& operator>>(wchar_t& ch);
CArchive& operator>>(unsigned& u);
CArchive& operator>>(bool& b);
CArchive& operator>>(ULONGLONG& dwdw);
CArchive& operator>>(LONGLONG& dwdw);

Retourwaarde

Een CArchive verwijzing die meerdere extractieoperators op één regel mogelijk maakt.

Opmerkingen

De laatste twee versies hierboven zijn specifiek bedoeld voor het laden van 64-bits gehele getallen.

Als u de IMPLEMENT_SERIAL macro in uw klasse-implementatie hebt gebruikt, worden de operatoren voor extractie overbelast om CObject de beveiligde ReadObject functie aan te roepen (met een niet-zero-runtime class pointer). Met deze functie wordt op zijn beurt de Serialize functie van de klasse aangeroepen.

De CStringT extractieoperator (>>) ondersteunt het laden vanuit een archief.

Voorbeelden

In dit voorbeeld ziet u het gebruik van de CArchive extractieoperator >> met het int type.

long l;
int i;
if (ar.IsLoading())
   ar >> l >> i;

In dit voorbeeld ziet u het gebruik van de CArchive invoeg- en extractieoperators << en >> met het CStringT type.

CString s;
if (ar.IsLoading())
   ar >> s;

CArchive::Read

Hiermee wordt een opgegeven aantal bytes uit het archief gelezen.

UINT Read(void* lpBuf, UINT nMax);

Parameterwaarden

lpBuf
Een aanwijzer naar een door de gebruiker opgegeven buffer die de gegevens uit het archief moet ontvangen.

nMax
Een geheel getal zonder teken waarmee het aantal bytes wordt opgegeven dat uit het archief moet worden gelezen.

Retourwaarde

Een geheel getal zonder teken dat het aantal bytes bevat dat daadwerkelijk wordt gelezen. Als de retourwaarde kleiner is dan het aangevraagde aantal, is het einde van het bestand bereikt. Er wordt geen uitzondering gegenereerd op basis van de voorwaarde voor het einde van het bestand.

Opmerkingen

Het archief interpreteert de bytes niet.

U kunt de lidfunctie in uw Read functie gebruiken voor het Serialize lezen van gewone structuren die zich in uw objecten bevinden.

Voorbeeld

char pbRead[100];
ar.Read(pbRead, 100);

CArchive::ReadClass

Roep deze lidfunctie aan om een verwijzing te lezen naar een klasse die eerder is opgeslagen met WriteClass.

CRuntimeClass* ReadClass(
    const CRuntimeClass* pClassRefRequested = NULL,
    UINT* pSchema = NULL,
    DWORD* pObTag = NULL);

Parameterwaarden

pClassRefRequested
Een aanwijzer naar de CRuntimeClass structuur die overeenkomt met de gevraagde klassereferentie. Kan zijn NULL.

pSchema
Een aanwijzer naar een schema van de runtimeklasse die eerder is opgeslagen.

pObTag
Een getal dat verwijst naar de unieke tag van een object. Intern gebruikt door de implementatie van ReadObject. Alleen beschikbaar gesteld voor geavanceerde programmering; pObTag normaal gesproken zou moeten zijn NULL.

Retourwaarde

Een aanwijzer naar de CRuntimeClass structuur.

Opmerkingen

Als pClassRefRequested dat niet NULLhet is, ReadClass controleert u of de gearchiveerde klasse-informatie compatibel is met uw runtimeklasse. Als het niet compatibel is, ReadClass werpt u een CArchiveException.

Uw runtimeklasse moet worden gebruikt DECLARE_SERIAL en IMPLEMENT_SERIALanders ReadClass wordt er een CNotSupportedException.

Als pSchema dat het is NULL, kan het schema van de opgeslagen klasse worden opgehaald door aan te roepen CArchive::GetObjectSchema; anders bevat het *pSchema schema van de runtimeklasse die eerder is opgeslagen.

U kunt SerializeClass in plaats van ReadClass, die zowel het lezen als schrijven van de klasreferentie afhandelt.

Voorbeeld

Zie het voorbeeld voor CArchive::WriteClass.

CArchive::ReadObject

Hiermee worden objectgegevens uit het archief gelezen en wordt een object van het juiste type samengesteld.

CObject* ReadObject(const CRuntimeClass* pClass);

Parameterwaarden

pClass
Een constante aanwijzer naar de CRuntimeClass structuur die overeenkomt met het object dat u verwacht te lezen.

Retourwaarde

Een CObject aanwijzer die veilig moet worden gecast naar de juiste afgeleide klasse met behulp van CObject::IsKindOf.

Opmerkingen

Deze functie wordt normaal gesproken aangeroepen door de CArchive extractieoperator (>>) overbelast voor een CObject aanwijzer. ReadObjectroept op zijn beurt de Serialize functie van de gearchiveerde klasse aan.

Als u een niet-nulparameter pClass opgeeft, die wordt verkregen door de RUNTIME_CLASS macro, controleert de functie de runtimeklasse van het gearchiveerde object. Hierbij wordt ervan uitgegaan dat u de IMPLEMENT_SERIAL macro hebt gebruikt in de implementatie van de klasse.

Voorbeeld

Zie het voorbeeld voor CArchive::WriteObject.

CArchive::ReadString

Roep deze lidfunctie aan om tekstgegevens te lezen in een buffer uit het bestand dat aan het CArchive object is gekoppeld.

BOOL ReadString(CString& rString);
LPTSTR ReadString(LPTSTR lpsz, UINT nMax);

Parameterwaarden

rString
Een verwijzing naar een CString bestand dat de resulterende tekenreeks bevat nadat deze is gelezen uit het bestand dat aan het CArchive object is gekoppeld.

lpsz
Hiermee geeft u een aanwijzer op naar een door de gebruiker opgegeven buffer die een door de gebruiker beëindigde teksttekenreeks ontvangt.

nMax
Hiermee geeft u het maximum aantal tekens op dat moet worden gelezen. Moet één kleiner zijn dan de grootte van de lpsz buffer.

Retourwaarde

In de versie die BOOL retourneert, indien geslaagd; TRUEFALSE anders.

In de versie die een LPTSTR, een aanwijzer naar de buffer met de tekstgegevens retourneert; NULL als het einde van het bestand is bereikt.

Opmerkingen

In de versie van de lidfunctie met de nMax parameter heeft de buffer een limiet van nMax - 1 tekens. Lezen wordt gestopt door een regelterugloopfeedpaar. Volgtekens van nieuwe regels worden altijd verwijderd. In NULL beide gevallen wordt een teken (\0) toegevoegd.

CArchive::Read is ook beschikbaar voor invoer in de tekstmodus, maar wordt niet beëindigd op een regelterugloopfeedpaar.

Voorbeeld

Zie het voorbeeld voor CArchive::WriteString.

CArchive::SerializeClass

Roep deze lidfunctie aan wanneer u de versiegegevens van een basisklasse wilt opslaan en laden.

void SerializeClass(const CRuntimeClass* pClassRef);

Parameterwaarden

pClassRef
Een aanwijzer naar een runtimeklasseobject voor de basisklasse.

Opmerkingen

SerializeClass leest of schrijft de verwijzing naar een klasse naar het CArchive object, afhankelijk van de richting van het CArchiveobject. Gebruik SerializeClass in plaats van ReadClass en WriteClass als een handige manier om objecten van basisklassen te serialiseren. SerializeClass Hiervoor zijn minder code en minder parameters vereist.

ReadClass Controleert bijvoorbeeld SerializeClassof de gearchiveerde klasse-informatie compatibel is met uw runtimeklasse. Als het niet compatibel is, SerializeClass werpt u een CArchiveException.

Uw runtimeklasse moet worden gebruikt DECLARE_SERIAL en IMPLEMENT_SERIALanders SerializeClass wordt er een CNotSupportedException.

Gebruik de RUNTIME_CLASS macro om de waarde voor de pRuntimeClass parameter op te halen. De basisklasse moet de IMPLEMENT_SERIAL macro hebben gebruikt.

Voorbeeld

class CBaseClass : public CObject
{
   DECLARE_SERIAL(CBaseClass);
};
class CDerivedClass : public CBaseClass
{
public:
   virtual void Serialize(CArchive &ar);
};
void CDerivedClass::Serialize(CArchive &ar)
{
   if (ar.IsStoring())
   {
      //normal code for storing contents
      //of this object
   }
   else
   {
      //normal code for reading contents
      //of this object
   }

   //allow the base class to serialize along
   //with its version information
   ar.SerializeClass(RUNTIME_CLASS(CBaseClass));
   CBaseClass::Serialize(ar);
}

CArchive::SetLoadParams

Aanroepen SetLoadParams wanneer u een groot aantal CObject-afgeleide objecten uit een archief gaat lezen.

void SetLoadParams(UINT nGrowBy = 1024);

Parameterwaarden

nGrowBy
Het minimum aantal elementsleuven dat moet worden toegewezen als een grootteverhoging nodig is.

Opmerkingen

CArchive maakt gebruik van een load array om verwijzingen naar objecten op te lossen die zijn opgeslagen in het archief. SetLoadParams hiermee kunt u de grootte instellen waarop de belastingmatrix groeit.

U mag geen aanroepen SetLoadParams nadat een object is geladen of nadat MapObject of ReadObject wordt aangeroepen.

Voorbeeld

class CMyLargeDocument : public CDocument
{
public:
   virtual void Serialize(CArchive &ar);
};
void CMyLargeDocument::Serialize(CArchive &ar)
{
   if (ar.IsStoring())
      ar.SetStoreParams(); // use large defaults
   else
      ar.SetLoadParams();

   if (ar.IsStoring())
   {
      // code for storing CMyLargeDocument
   }
   else
   {
      // code for loading CMyLargeDocument
   }
}

CArchive::SetObjectSchema

Roep deze lidfunctie aan om het objectschema in te stellen dat is opgeslagen in het archiefobject op nSchema.

void SetObjectSchema(UINT nSchema);

Parameterwaarden

nSchema
Hiermee geeft u het schema van het object.

Opmerkingen

Met de volgende aanroep GetObjectSchema wordt de waarde geretourneerd die is opgeslagen in nSchema.

Gebruik SetObjectSchema deze functie voor geavanceerde versiebeheer. Als u bijvoorbeeld wilt afdwingen dat een bepaalde versie wordt gelezen in een Serialize functie van een afgeleide klasse.

Voorbeeld

ar.SetObjectSchema(2);
ASSERT(2 == ar.GetObjectSchema());

CArchive::SetStoreParams

Gebruik SetStoreParams deze functie bij het opslaan van een groot aantal CObject-afgeleide objecten in een archief.

void SetStoreParams(UINT nHashSize = 2053, UINT nBlockSize = 128);

Parameterwaarden

nHashSize
De grootte van de hash-tabel voor interfacepointertoewijzingen. Moet een priemnummer zijn.

nBlockSize
Hiermee geeft u de granulariteit voor geheugentoewijzing voor het uitbreiden van de parameters. Moet een vermogen van 2 zijn voor de beste prestaties.

Opmerkingen

SetStoreParams hiermee kunt u de grootte van de hash-tabel en de blokgrootte van de kaart instellen die wordt gebruikt om unieke objecten te identificeren tijdens het serialisatieproces.

U mag niet aanroepen SetStoreParams nadat objecten zijn opgeslagen, of na MapObject of WriteObject wordt aangeroepen.

Voorbeeld

class CMyLargeDocument : public CDocument
{
public:
   virtual void Serialize(CArchive &ar);
};
void CMyLargeDocument::Serialize(CArchive &ar)
{
   if (ar.IsStoring())
      ar.SetStoreParams(); // use large defaults
   else
      ar.SetLoadParams();

   if (ar.IsStoring())
   {
      // code for storing CMyLargeDocument
   }
   else
   {
      // code for loading CMyLargeDocument
   }
}

CArchive::Write

Hiermee schrijft u een opgegeven aantal bytes naar het archief.

void Write(const void* lpBuf, INT nMax);

Parameterwaarden

lpBuf
Een aanwijzer naar een door de gebruiker geleverde buffer die de gegevens bevat die naar het archief moeten worden geschreven.

nMax
Een geheel getal dat het aantal bytes aangeeft dat naar het archief moet worden geschreven.

Opmerkingen

Het archief maakt de bytes niet op.

U kunt de Write lidfunctie in uw Serialize functie gebruiken om gewone structuren te schrijven die zich in uw objecten bevinden.

Voorbeeld

char pbWrite[100];
memset(pbWrite, 'a', 100);
ar.Write(pbWrite, 100);

CArchive::WriteClass

Gebruik WriteClass deze optie om de versie- en klassegegevens van een basisklasse op te slaan tijdens de serialisatie van de afgeleide klasse.

void WriteClass(const CRuntimeClass* pClassRef);

Parameterwaarden

pClassRef
Een aanwijzer naar de CRuntimeClass structuur die overeenkomt met de gevraagde klassereferentie.

Opmerkingen

WriteClass schrijft een verwijzing naar de CRuntimeClass basisklasse naar de CArchive. Gebruik CArchive::ReadClass dit om de verwijzing op te halen.

WriteClass Controleert of de gearchiveerde klasse-informatie compatibel is met uw runtimeklasse. Als het niet compatibel is, WriteClass werpt u een CArchiveException.

Uw runtimeklasse moet worden gebruikt DECLARE_SERIAL en IMPLEMENT_SERIALanders WriteClass wordt er een CNotSupportedException.

U kunt SerializeClass in plaats van WriteClass, die zowel het lezen als schrijven van de klasreferentie afhandelt.

Voorbeeld

CFile myFile(_T("My__test__file.dat"),
             CFile::modeCreate | CFile::modeReadWrite);

// Create a storing archive.
CArchive arStore(&myFile, CArchive::store);

// Store the class CAge in the archive.
arStore.WriteClass(RUNTIME_CLASS(CAge));

// Close the storing archive.
arStore.Close();

// Create a loading archive.
myFile.SeekToBegin();
CArchive arLoad(&myFile, CArchive::load);

// Load a class from the archive.
CRuntimeClass *pClass = arLoad.ReadClass();
if (!pClass->IsDerivedFrom(RUNTIME_CLASS(CAge)))
{
   arLoad.Abort();
}

CArchive::WriteObject

Slaat de opgegeven CObject waarde op in het archief.

void WriteObject(const CObject* pOb);

Parameterwaarden

pOb
Een constante aanwijzer naar het object dat wordt opgeslagen.

Opmerkingen

Deze functie wordt normaal gesproken aangeroepen door de CArchive invoegoperator (<<) overbelast voor CObject. WriteObjectroept op zijn beurt de Serialize functie van de gearchiveerde klasse aan.

U moet de IMPLEMENT_SERIAL macro gebruiken om archivering in te schakelen. WriteObject schrijft de naam van de ASCII-klasse naar het archief. Deze klassenaam wordt later tijdens het laadproces gevalideerd. Een speciaal coderingsschema voorkomt onnodige duplicatie van de klassenaam voor meerdere objecten van de klasse. Dit schema voorkomt ook redundante opslag van objecten die doelen zijn van meer dan één aanwijzer.

De exacte objectcoderingsmethode (inclusief de aanwezigheid van de ASCII-klassenaam) is een implementatiedetail en kan in toekomstige versies van de bibliotheek veranderen.

Opmerking

Voltooi het maken, verwijderen en bijwerken van al uw objecten voordat u ze gaat archiveren. Uw archief is beschadigd als u archivering combineert met objectwijziging.

Voorbeeld

Zie het voorbeeld voor CAgeeen definitie van de klasseCObList::CObList.

CFile myFile(_T("My__test__file.dat"),
             CFile::modeCreate | CFile::modeReadWrite);
CAge age(21), *pAge;

// Create a storing archive.
CArchive arStore(&myFile, CArchive::store);

// Write the object to the archive
arStore.WriteObject(&age);

// Close the storing archive
arStore.Close();

// Create a loading archive.
myFile.SeekToBegin();
CArchive arLoad(&myFile, CArchive::load);

// Verify the object is in the archive.
pAge = (CAge *)arLoad.ReadObject(RUNTIME_CLASS(CAge));
ASSERT(age == *pAge);

CArchive::WriteString

Gebruik deze lidfunctie om gegevens van een buffer te schrijven naar het bestand dat aan het CArchive object is gekoppeld.

void WriteString(LPCTSTR lpsz);

Parameterwaarden

lpsz
Hiermee geeft u een aanwijzer op naar een buffer met een tekenreeks die null-beëindigde tekst bevat.

Opmerkingen

Het afsluitende null-teken (\0) wordt niet naar het bestand geschreven; evenmin is er automatisch een nieuwe regel geschreven.

WriteString genereert een uitzondering als reactie op verschillende voorwaarden, met inbegrip van de schijf-volledige voorwaarde.

Write is ook beschikbaar, maar in plaats van te beëindigen op een null-teken, wordt het aangevraagde aantal bytes naar het bestand geschreven.

Voorbeeld

CFile myFile(_T("My__test__file.dat"),
             CFile::modeCreate | CFile::modeReadWrite);
CString str1("String1"), str2("String2"), str;

// Create a storing archive.
CArchive arStore(&myFile, CArchive::store);

// Write str1 and str2 to the archive
arStore.WriteString(str1);
arStore.WriteString(_T("\n"));
arStore.WriteString(str2);
arStore.WriteString(_T("\n"));

// Close the storing archive
arStore.Close();

// Create a loading archive.
myFile.SeekToBegin();
CArchive arLoad(&myFile, CArchive::load);

// Verify the two strings are in the archive.
arLoad.ReadString(str);
ASSERT(str == str1);
arLoad.ReadString(str);
ASSERT(str == str2);

Zie ook

Hiërarchiegrafiek
CFile klasse
CObject klasse
CSocket klasse
CSocketFile klasse