CArchive-klass

Gör att du kan spara ett komplext nätverk av objekt i permanent binär form (vanligtvis disklagring) som bevaras efter att dessa objekt har tagits bort.

Syntax

class CArchive

Medlemmar

Offentliga konstruktorer

Offentliga metoder

Offentliga operatörer

Medlemmar i offentliga data

Anmärkningar

CArchive har ingen basklass.

Senare kan du läsa in objekten från beständig lagring och återskapa dem i minnet. Den här processen för att göra data beständiga kallas "serialisering".

Du kan se ett arkivobjekt som en slags binär dataström. Precis som en indata-/utdataström är ett arkiv associerat med en fil och tillåter buffrad skrivning och läsning av data till och från lagring. En indata-/utdataström bearbetar sekvenser med ASCII-tecken, men ett arkiv bearbetar binära objektdata i ett effektivt, icke-överskådlig format.

Du måste skapa ett CFile objekt innan du kan skapa ett CArchive objekt. Dessutom måste du se till att arkivets inläsnings-/lagringsstatus är kompatibel med filens öppna läge. Du är begränsad till ett aktivt arkiv per fil.

När du skapar ett CArchive objekt bifogar du det till ett objekt av klassen CFile (eller en härledd klass) som representerar en öppen fil. Du anger också om arkivet ska användas för inläsning eller lagring. Ett CArchive objekt kan bearbeta inte bara primitiva typer utan även objekt av CObject-derived-klasser som är utformade för serialisering. En serialiserbar klass har vanligtvis en Serialize medlemsfunktion och använder vanligtvis makrona och DECLARE_SERIAL enligt beskrivningen IMPLEMENT_SERIAL under klassen CObject.

Operatorerna för överlagrad extrahering (>>) och insättning (<<) är praktiska arkivprogrammeringsgränssnitt som stöder både primitiva typer och CObject-härledda klasser.

CArchive stöder även programmering med MFC Windows Sockets-klasserna CSocket och CSocketFile. Medlemsfunktionen IsBufferEmpty stöder den användningen.

Mer information om CArchivefinns i artiklarna Serialisering och Windows Sockets: Using Sockets with Archives (Använda socketar med arkiv).

Arvshierarki

CArchive

Kravspecifikation

rubrik:afx.h

CArchive::Abort

Anropa den här funktionen för att stänga arkivet utan att utlösa ett undantag.

void Abort ();

Anmärkningar

Destructor CArchive anropar Closenormalt , vilket rensar alla data som inte har sparats i det associerade CFile objektet. Detta kan orsaka undantag.

När du tar dessa undantag är det en bra idé att använda Abort, så att CArchive det inte orsakar ytterligare undantag om objektet förstörs. Vid hantering av undantag CArchive::Abort utlöser inte ett undantag vid fel eftersom, till skillnad från CArchive::Close, Abort ignorerar fel.

Om du använde new för att allokera CArchive objektet på heapen måste du ta bort det när du har stängt filen.

Exempel

Se exemplet för CArchive::WriteClass.

CArchive::CArchive

Konstruerar ett CArchive objekt och anger om det ska användas för att läsa in eller lagra objekt.

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

Parameterar

pFile
En pekare till objektet CFile som är den ultimata källan eller målet för beständiga data.

nMode
En flagga som anger om objekt ska läsas in från eller lagras i arkivet. Parametern nMode måste ha något av följande värden:

• CArchive::load Läser in data från arkivet. Kräver endast CFile läsbehörighet.

• CArchive::store Sparar data i arkivet. Kräver CFile skrivbehörighet.

• CArchive::bNoFlushOnDelete Förhindrar att arkivet anropas automatiskt Flush när arkivförstöraren anropas. Om du anger den här flaggan ansvarar du för att uttryckligen anropa Close innan destrueringsverktyget anropas. Om du inte gör det skadas dina data.

nBufSize
Ett heltal som anger storleken på den interna filbufferten i byte. Observera att standardbuffertstorleken är 4 096 byte. Om du rutinmässigt arkiverar stora objekt förbättrar du prestandan om du använder en större buffertstorlek som är en multipel av filbuffertstorleken.

lpBuf
En valfri pekare till en buffert som tillhandahålls av användaren med storleken nBufSize. Om du inte anger den här parametern allokerar arkivet en buffert från den lokala heapen och frigör den när objektet förstörs. Arkivet frigör inte en buffert som tillhandahålls av användaren.

Anmärkningar

Du kan inte ändra den här specifikationen när du har skapat arkivet.

Du får inte använda CFile åtgärder för att ändra filens tillstånd förrän du har stängt arkivet. Alla sådana åtgärder kommer att skada arkivets integritet. Du kan komma åt filpekarens position när som helst under serialiseringen genom att hämta arkivets filobjekt från GetFile medlemsfunktionen och sedan använda CFile::GetPosition funktionen. Du bör anropa CArchive::Flush innan du hämtar filpekarens position.

Exempel

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

Rensar alla data som finns kvar i bufferten, stänger arkivet och kopplar från arkivet från filen.

void Close();

Anmärkningar

Inga ytterligare åtgärder i arkivet tillåts. När du har stängt ett arkiv kan du skapa ett annat arkiv för samma fil eller stänga filen.

Medlemsfunktionen Close ser till att alla data överförs från arkivet till filen och att arkivet blir otillgängligt. För att slutföra överföringen från filen till lagringsmediet måste du först använda CFile::Close och sedan förstöra CFile objektet.

Exempel

Se exemplet för CArchive::WriteString.

CArchive::Flush

Tvingar alla data som finns kvar i arkivbufferten att skrivas till filen.

void Flush();

Anmärkningar

Medlemsfunktionen Flush säkerställer att alla data överförs från arkivet till filen. Du måste anropa CFile::Close för att slutföra överföringen från filen till lagringsmediet.

Exempel

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

Hämtar objektpekaren CFile för det här arkivet.

CFile* GetFile() const;

Returvärde

En konstant pekare till det objekt som CFile används.

Anmärkningar

Du måste rensa arkivet innan du använder GetFile.

Exempel

const CFile *fp = ar.GetFile();

CArchive::GetObjectSchema

Anropa den Serialize här funktionen från funktionen för att fastställa vilken version av objektet som för närvarande deserialiseras.

UINT GetObjectSchema();

Returvärde

Under deserialiseringen läser du versionen av objektet.

Anmärkningar

Att anropa den här funktionen är bara giltigt när CArchive objektet läses in ( CArchive::IsLoading returnerar nonzero). Det bör vara det första anropet Serialize i funktionen och anropas bara en gång. Ett returvärde för ( UINT)-1 anger att versionsnumret är okänt.

En CObject-härledd klass kan använda VERSIONABLE_SCHEMA kombinerat (med bitvis "eller" (|)) med själva schemaversionen (i IMPLEMENT_SERIAL makrot) för att skapa ett "versionsbart objekt", dvs. ett objekt vars Serialize medlemsfunktion kan läsa flera versioner. Standardramverksfunktionen (utan VERSIONABLE_SCHEMA) är att utlösa ett undantag när versionen är matchningslös.

Exempel

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

Anropa den här medlemsfunktionen för att avgöra om arkivobjektets interna buffert är tom.

BOOL IsBufferEmpty() const;

Returvärde

Nonzero om arkivets buffert är tom; annars 0.

Anmärkningar

Den här funktionen tillhandahålls för programmering med klassen CSocketFileMFC Windows Sockets . Du behöver inte använda den för ett arkiv som är associerat med ett CFile objekt.

Anledningen till att använda IsBufferEmpty med ett arkiv som är associerat med ett CSocketFile objekt är att arkivets buffert kan innehålla mer än ett meddelande eller en post. När du har fått ett meddelande bör du använda IsBufferEmpty för att styra en loop som fortsätter att ta emot data tills bufferten är tom. Mer information finns i Receive medlemsfunktionen i klassen CAsyncSocket, som visar hur du använder IsBufferEmpty.

Mer information finns i Windows Sockets: Using Sockets with Archives (Använda socketar med arkiv).

CArchive::IsLoading

Avgör om arkivet läser in data.

BOOL IsLoading() const;

Returvärde

Nonzero om arkivet för närvarande används för inläsning; annars 0.

Anmärkningar

Den här medlemsfunktionen anropas av funktionerna i Serialize de arkiverade klasserna.

Exempel

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

CArchive::IsStoring

Avgör om arkivet lagrar data.

BOOL IsStoring() const;

Returvärde

Nonzero om arkivet för närvarande används för lagring; annars 0.

Anmärkningar

Den här medlemsfunktionen anropas av funktionerna i Serialize de arkiverade klasserna.

Om statusen för IsStoring ett arkiv inte är noll är dess IsLoading status 0 och vice versa.

Exempel

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

CArchive::MapObject

Anropa den här medlemsfunktionen för att placera objekt på kartan som egentligen inte serialiseras till filen, men som är tillgängliga för underobjekt att referera till.

void MapObject(const CObject* pOb);

Parameterar

pOb
En konstant pekare till objektet som lagras.

Anmärkningar

Du kanske till exempel inte serialiserar ett dokument, men du serialiserar de objekt som ingår i dokumentet. Genom att anropa MapObjecttillåter du att dessa objekt, eller underobjekt, refererar till dokumentet. Dessutom kan serialiserade underwebbplatser serialisera sin m_pDocument backpekare.

Du kan anropa MapObject när du lagrar till och läser in från objektet CArchive . MapObject lägger till det angivna objektet i de interna datastrukturer som underhålls av CArchive objektet under serialisering och deserialisering, men till skillnad från ReadObject och WriteObjectanropar det inte serialisera på objektet.

Exempel

//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 Den här pekaren CDocument är inställd på som standard och kan ställas in på vad som helst som användaren av instansen CArchive vill ha.

CDocument* m_pDocument;

Anmärkningar

En vanlig användning av den här pekaren är att förmedla ytterligare information om serialiseringsprocessen till alla objekt som serialiseras. Detta uppnås genom att initiera pekaren med dokumentet (en CDocument-härledd klass) som serialiseras, på ett sådant sätt att objekt i dokumentet kan komma åt dokumentet om det behövs. Den här pekaren används också av COleClientItem objekt under serialiseringen.

Ramverket anger m_pDocument det dokument som serialiseras när en användare utfärdar ett filöppnings- eller spara-kommando. Om du serialiserar ett OLE-containerdokument (Object Linking and Embedding) av andra skäl än Öppna eller Spara måste du uttryckligen ange m_pDocument. Du kan till exempel göra detta när du serialiserar ett containerdokument till Urklipp.

Exempel

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 <<

Lagrar det angivna objektet eller den primitiva typen i arkivet.

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);

Returvärde

En CArchive referens som möjliggör flera infogningsoperatorer på en enda rad.

Anmärkningar

De två senaste versionerna ovan är specifikt för lagring av 64-bitars heltal.

Om du använde makrot IMPLEMENT_SERIAL i klassimplementeringen överbelastades infogningsoperatorn för CObject anrop till det skyddade WriteObject. Den här funktionen anropar Serialize i sin tur klassens funktion.

Infogningsoperatorn CStringT (<<) stöder diagnostisk dumpning och lagring i ett arkiv.

Exempel

Det här exemplet visar användningen av CArchive infogningsoperatorn << med typerna int och long .

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

Det här exemplet visar användningen av CArchive infogningsoperatorn << med CStringT typen .

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

CArchive::operator >>

Läser in det angivna objektet eller den primitiva typen från arkivet.

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);

Returvärde

En CArchive referens som möjliggör flera extraheringsoperatorer på en enda rad.

Anmärkningar

De två senaste versionerna ovan är specifikt för inläsning av 64-bitars heltal.

Om du använde makrot IMPLEMENT_SERIAL i din klassimplementering överbelastades extraheringsoperatorerna för CObject att anropa den skyddade ReadObject funktionen (med en icke-zero-körningsklasspekare). Den här funktionen anropar Serialize i sin tur klassens funktion.

Extraheringsoperatorn CStringT (>>) stöder inläsning från ett arkiv.

Exempel

Det här exemplet visar användningen av extraheringsoperatorn CArchive>> med int typen .

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

Det här exemplet visar användningen av CArchive infognings- och extraheringsoperatorerna << och >> med CStringT typen .

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

CArchive::Read

Läser ett angivet antal byte från arkivet.

UINT Read(void* lpBuf, UINT nMax);

Parameterar

lpBuf
En pekare till en buffert från användaren som ska ta emot data som lästs från arkivet.

nMax
Ett osignerat heltal som anger antalet byte som ska läsas från arkivet.

Returvärde

Ett osignerat heltal som innehåller antalet byte som faktiskt lästs. Om returvärdet är mindre än det begärda talet har filslutet nåtts. Inget undantag utlöses i villkoret för filslut.

Anmärkningar

Arkivet tolkar inte byte.

Du kan använda Read medlemsfunktionen i din Serialize funktion för att läsa vanliga strukturer som finns i dina objekt.

Exempel

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

CArchive::ReadClass

Anropa den här medlemsfunktionen för att läsa en referens till en klass som tidigare lagrats med WriteClass.

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

Parameterar

pClassRefRequested
En pekare till den CRuntimeClass struktur som motsvarar den begärda klassreferensen. Kan vara NULL.

pSchema
En pekare till ett schema för den körningsklass som tidigare lagrats.

pObTag
Ett tal som refererar till ett objekts unika tagg. Används internt av implementeringen av ReadObject. Exponeras endast för avancerad programmering. pObTag normalt ska vara NULL.

Returvärde

En pekare till CRuntimeClass strukturen.

Anmärkningar

Om pClassRefRequested inte NULLverifierar du ReadClass att den arkiverade klassinformationen är kompatibel med din runtime-klass. Om den inte är kompatibel ReadClass genererar den en CArchiveException.

Din körningsklass måste använda DECLARE_SERIAL och IMPLEMENT_SERIAL, annars ReadClass genererar en CNotSupportedException.

Om pSchema är NULL, kan schemat för den lagrade klassen hämtas genom att anropa CArchive::GetObjectSchema. Annars *pSchema innehåller schemat för den körningsklass som tidigare lagrades.

Du kan använda SerializeClass i stället för ReadClass, som hanterar både läsning och skrivning av klassreferensen.

Exempel

Se exemplet för CArchive::WriteClass.

CArchive::ReadObject

Läser objektdata från arkivet och konstruerar ett objekt av lämplig typ.

CObject* ReadObject(const CRuntimeClass* pClass);

Parameterar

pClass
En konstant pekare till strukturen CRuntimeClass som motsvarar det objekt som du förväntar dig att läsa.

Returvärde

En CObject pekare som säkert måste gjutas till rätt härledd klass med hjälp CObject::IsKindOfav .

Anmärkningar

Den här funktionen anropas normalt av extraheringsoperatorn CArchive (>>) som är överbelastad för en CObject pekare. ReadObjectanropar i sin tur funktionen för Serialize den arkiverade klassen.

Om du anger en nonzero-parameter pClass , som hämtas av RUNTIME_CLASS makrot, verifierar funktionen körningsklassen för det arkiverade objektet. Detta förutsätter att du har använt makrot IMPLEMENT_SERIAL i implementeringen av klassen.

Exempel

Se exemplet för CArchive::WriteObject.

CArchive::ReadString

Anropa den här medlemsfunktionen för att läsa textdata till en buffert från filen som är associerad med CArchive objektet.

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

Parameterar

rString
En referens till en CString som innehåller den resulterande strängen när den har lästs från filen som är associerad med CArchive objektet.

lpsz
Anger en pekare till en buffert från användaren som får en null-avslutad textsträng.

nMax
Anger det maximala antalet tecken som ska läsas. Bör vara en mindre än buffertens lpsz storlek.

Returvärde

I den version som returnerar BOOL, TRUE om det lyckas, FALSE annars.

I den version som returnerar en LPTSTRpekare till bufferten som innehåller textdata, NULL om filslutet har nåtts.

Anmärkningar

I versionen av medlemsfunktionen med parametern nMax rymmer bufferten upp till en gräns på nMax - 1 tecken. Läsning stoppas av ett returlinjematningspar för vagn. Avslutande nya tecken tas alltid bort. Ett NULL tecken (\0) läggs till i båda fallen.

CArchive::Read är också tillgängligt för textlägesindata, men avslutas inte på ett returlinjematningspar för vagn.

Exempel

Se exemplet för CArchive::WriteString.

CArchive::SerializeClass

Anropa den här medlemsfunktionen när du vill lagra och läsa in versionsinformationen för en basklass.

void SerializeClass(const CRuntimeClass* pClassRef);

Parameterar

pClassRef
En pekare till ett körningsklassobjekt för basklassen.

Anmärkningar

SerializeClass läser eller skriver referensen till en klass till CArchive objektet, beroende på riktningen för CArchive. Använd SerializeClass i stället för ReadClass och WriteClass som ett bekvämt sätt att serialisera basklassobjekt. SerializeClass Kräver mindre kod och färre parametrar.

Som ReadClass, SerializeClass verifierar att den arkiverade klassinformationen är kompatibel med din körningsklass. Om den inte är kompatibel SerializeClass genererar den en CArchiveException.

Din körningsklass måste använda DECLARE_SERIAL och IMPLEMENT_SERIAL, annars SerializeClass genererar en CNotSupportedException.

Använd makrot RUNTIME_CLASS för att hämta värdet för parametern pRuntimeClass . Basklassen måste ha använt makrot IMPLEMENT_SERIAL .

Exempel

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

Anropa SetLoadParams när du ska läsa ett stort antal CObject-härledda objekt från ett arkiv.

void SetLoadParams(UINT nGrowBy = 1024);

Parameterar

nGrowBy
Det minsta antalet elementplatser som ska allokeras om en storleksökning krävs.

Anmärkningar

CArchive använder en inläsningsmatris för att matcha referenser till objekt som lagras i arkivet. SetLoadParams gör att du kan ange den storlek som belastningsmatrisen växer till.

Du får inte anropa SetLoadParams efter att något objekt har lästs in eller efter MapObject eller ReadObject anropats.

Exempel

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

Anropa den här medlemsfunktionen för att ange objektschemat som lagras i arkivobjektet till nSchema.

void SetObjectSchema(UINT nSchema);

Parameterar

nSchema
Anger objektets schema.

Anmärkningar

Nästa anrop till GetObjectSchema returnerar värdet som lagras i nSchema.

Använd SetObjectSchema för avancerad versionshantering, till exempel när du vill tvinga en viss version att läsas i en Serialize funktion i en härledd klass.

Exempel

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

CArchive::SetStoreParams

Använd SetStoreParams när du lagrar ett stort antal CObject-härledda objekt i ett arkiv.

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

Parameterar

nHashSize
Storleken på hash-tabellen för gränssnittspekarkartor. Bör vara ett primtal.

nBlockSize
Anger minnesallokeringskornigheten för att utöka parametrarna. Bör vara en effekt på 2 för bästa prestanda.

Anmärkningar

SetStoreParams gör att du kan ange hashtabellens storlek och blockstorleken för den karta som används för att identifiera unika objekt under serialiseringsprocessen.

Du får inte anropa SetStoreParams efter att några objekt har lagrats eller efter MapObject eller WriteObject anropats.

Exempel

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

Skriver ett angivet antal byte till arkivet.

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

Parameterar

lpBuf
En pekare till en buffert från användaren som innehåller de data som ska skrivas till arkivet.

nMax
Ett heltal som anger hur många byte som ska skrivas till arkivet.

Anmärkningar

Arkivet formaterar inte byte.

Du kan använda Write medlemsfunktionen i funktionen Serialize för att skriva vanliga strukturer som finns i dina objekt.

Exempel

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

CArchive::WriteClass

Använd WriteClass för att lagra version och klassinformation för en basklass under serialiseringen av den härledda klassen.

void WriteClass(const CRuntimeClass* pClassRef);

Parameterar

pClassRef
En pekare till den CRuntimeClass struktur som motsvarar den begärda klassreferensen.

Anmärkningar

WriteClass skriver en referens till CRuntimeClass för basklassen CArchivetill . Använd CArchive::ReadClass för att hämta referensen.

WriteClass verifierar att den arkiverade klassinformationen är kompatibel med din körningsklass. Om den inte är kompatibel WriteClass genererar den en CArchiveException.

Din körningsklass måste använda DECLARE_SERIAL och IMPLEMENT_SERIAL, annars WriteClass genererar en CNotSupportedException.

Du kan använda SerializeClass i stället för WriteClass, som hanterar både läsning och skrivning av klassreferensen.

Exempel

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

Lagrar det angivna CObject i arkivet.

void WriteObject(const CObject* pOb);

Parameterar

pOb
En konstant pekare till objektet som lagras.

Anmärkningar

Den här funktionen anropas normalt av infogningsoperatorn CArchive (<<) som är överbelastad för CObject. WriteObjectanropar i sin tur funktionen för Serialize den arkiverade klassen.

Du måste använda makrot IMPLEMENT_SERIAL för att aktivera arkivering. WriteObject skriver ASCII-klassnamnet till arkivet. Det här klassnamnet verifieras senare under inläsningsprocessen. Ett särskilt kodningsschema förhindrar onödig duplicering av klassnamnet för flera objekt i klassen. Det här schemat förhindrar också redundant lagring av objekt som är mål för mer än en pekare.

Den exakta objektkodningsmetoden (inklusive förekomsten av ASCII-klassnamnet) är en implementeringsinformation och kan ändras i framtida versioner av biblioteket.

Exempel

En definition av klassen CAgefinns i exemplet för CObList::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

Använd den här medlemsfunktionen för att skriva data från en buffert till filen som är associerad med CArchive objektet.

void WriteString(LPCTSTR lpsz);

Parameterar

lpsz
Anger en pekare till en buffert som innehåller en null-avslutad textsträng.

Anmärkningar

Det avslutande null-tecknet (\0) skrivs inte till filen. inte heller skrivs en ny rad automatiskt.

WriteString genererar ett undantag som svar på flera villkor, inklusive diskens fullständiga villkor.

Write är också tillgängligt, men i stället för att avslutas med ett null-tecken skrivs det begärda antalet byte till filen.

Exempel

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);

Se även

hierarkidiagram
CFile klass
CObject klass
CSocket klass
CSocketFile klass