Megosztás:

CArchive osztály

Lehetővé teszi az objektumok összetett hálózatának állandó bináris formában (általában lemeztárolóban) történő mentését, amely az objektumok törlése után is megmarad.

Szemantika

class CArchive

Tagok

Nyilvános konstruktorok

Név Leírás
CArchive::CArchive Létrehoz egy CArchive objektumot.

Nyilvános metódusok

Név Leírás
CArchive::Abort Bezár egy archívumot kivétel nélkül.
CArchive::Close Kiüríti a nem írott adatokat, és leválasztja a CFile.
CArchive::Flush A nem írott adatok kiürítése az archív pufferből.
CArchive::GetFile Lekéri az CFile archívum objektummutatóját.
CArchive::GetObjectSchema A függvényből Serialize meghívva határozza meg a deszerializálandó objektum verzióját.
CArchive::IsBufferEmpty Meghatározza, hogy a puffer kiürítve lett-e a Windows-szoftvercsatornák fogadási folyamata során.
CArchive::IsLoading Meghatározza, hogy az archívum betöltődik-e.
CArchive::IsStoring Meghatározza, hogy az archívum tárol-e.
CArchive::MapObject Olyan objektumokat helyez el a térképen, amelyek nem szerializálva vannak a fájlban, de amelyek hivatkozásra elérhetők az alobjektumok számára.
CArchive::Read Nyers bájtokat olvas be.
CArchive::ReadClass Beolvassa a korábban a következővel tárolt osztályhivatkozást WriteClass: .
CArchive::ReadObject Meghívja egy objektum függvényét Serialize a betöltéshez.
CArchive::ReadString Egyetlen sornyi szöveget olvas be.
CArchive::SerializeClass Beolvassa vagy megírja az osztályhivatkozást az CArchive objektumra az CArchiveirányától függően.
CArchive::SetLoadParams A terhelési tömb méretének beállítása. Minden objektum betöltése előtt vagy előtt vagy meghívása előtt MapObjectReadObject kell meghívni.
CArchive::SetObjectSchema Beállítja az archív objektumban tárolt objektumsémát.
CArchive::SetStoreParams Beállítja a kivonattábla méretét és a térkép blokkméretét, amellyel egyedi objektumokat azonosíthat a szerializálási folyamat során.
CArchive::Write Nyers bájtokat ír.
CArchive::WriteClass A parancsra CRuntimeClassCArchivemutató hivatkozást ír.
CArchive::WriteObject Meghívja egy objektum függvényét Serialize a tároláshoz.
CArchive::WriteString Egyetlen sornyi szöveget ír.

Nyilvános operátorok

Név Leírás
CArchive::operator << Objektumokat és primitív típusokat tárol az archívumban.
CArchive::operator >> Betölti az objektumokat és a primitív típusokat az archívumból.

Nyilvános adatok tagjai

Név Leírás
CArchive::m_pDocument

Megjegyzések

CArchive nem rendelkezik alaposztálysal.

Később betöltheti az objektumokat az állandó tárolóból, és újra létrehozhatja őket a memóriában. Az adatok állandósításának folyamatát "szerializálásnak" nevezzük.

Az archív objektum egyfajta bináris adatfolyamként is felfogható. A bemeneti/kimeneti adatfolyamokhoz hasonlóan az archívum is egy fájlhoz van társítva, és lehetővé teszi az adatok pufferelt írását és beolvasását a tárolóba és a tárolóból. A bemeneti/kimeneti adatfolyam ASCII-karakterek sorozatait dolgozza fel, de az archívum a bináris objektumadatokat hatékony, nem dedundáns formátumban dolgozza fel.

Mielőtt létrehozhat egy objektumot, létre kell hoznia egy CFile objektumot CArchive . Emellett gondoskodnia kell arról, hogy az archívum betöltési/tárolási állapota kompatibilis legyen a fájl nyílt módjával. Fájlonként csak egy aktív archívumot használhat.

Objektum létrehozásakor CArchive egy megnyitott fájlt jelképező osztályobjektumhoz CFile (vagy származtatott osztályhoz) csatolja. Azt is megadhatja, hogy az archívum betöltésre vagy tárolásra lesz-e használva. Az CArchive objektumok nem csak a primitív típusokat, hanem a szerializálásra tervezett származtatott osztályok objektumait CObjectis feldolgozhatják. A szerializálható osztály általában tagfüggvényekkel rendelkezikSerialize, és általában az DECLARE_SERIAL osztályban IMPLEMENT_SERIALleírt makrókat és CObject makrókat használja.

A túlterhelt extrakciós (>>) és beszúrási (<<) operátorok kényelmes archív programozási felületek, amelyek a primitív típusokat és CObjecta származtatott osztályokat egyaránt támogatják.

CArchive emellett támogatja a programozást az MFC Windows Sockets osztályokkal CSocket és CSocketFile. A IsBufferEmpty tagfüggvény támogatja ezt a használatot.

További információ: CArchiveSzerializálás és Windows-szoftvercsatornák: Szoftvercsatornák használata archívumokkal.

Öröklési hierarchia

CArchive

Követelmények

fejléc:afx.h

CArchive::Abort

Hívja meg ezt a függvényt, hogy kivétel nélkül zárja be az archívumot.

void Abort ();

Megjegyzések

A CArchive destruktor általában meghívja Closeazokat az adatokat, amelyeket nem mentettek a társított objektumba CFile . Ez kivételeket okozhat.

A kivételek észlelésekor érdemes használni Abort, hogy az CArchive objektum destrukturálása ne okozzon további kivételeket. A kivételek CArchive::Abort kezelésekor nem fog kivételt kivenni a hibákból, mert a hibákkal ellentétben CArchive::CloseAbort figyelmen kívül hagyja a hibákat.

Ha az objektumot a new halomra osztottaCArchive, akkor a fájl bezárása után törölnie kell.

példa

Lásd a példát a CArchive::WriteClass.

CArchive::CArchive

Létrehoz egy CArchive objektumot, és megadja, hogy az objektumok betöltésére vagy tárolására lesz-e használva.

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

Paraméterek

pFile
Mutató arra az CFile objektumra, amely az állandó adatok végső forrása vagy célja.

nMode
Egy jelölő, amely megadja, hogy az objektumok betölthetők-e az archívumból vagy az archívumba. A nMode paraméternek az alábbi értékek egyikével kell rendelkeznie:

  • CArchive::load Adatok betöltése az archívumból. Csak CFile olvasási engedély szükséges.

  • CArchive::store Adatokat ment az archívumba. Írási engedélyt igényel CFile .

  • CArchive::bNoFlushOnDelete Megakadályozza, hogy az archívum automatikusan meghívja Flush az archív destruktor meghívását. Ha ezt a jelzőt állítja be, a destruktor meghívása előtt ön a felelős a kifejezett hívásért Close . Ha nem teszi meg, az adatok sérültek lesznek.

nBufSize
A belső fájlpuffer méretét bájtban megadó egész szám. Vegye figyelembe, hogy az alapértelmezett pufferméret 4096 bájt. Ha rendszeresen archiválja a nagyméretű objektumokat, akkor javítja a teljesítményt, ha nagyobb pufferméretet használ, amely a fájlpuffer méretének többszöröse.

lpBuf
Opcionális mutató egy felhasználó által megadott méretű nBufSizepufferre. Ha nem adja meg ezt a paramétert, az archívum lefoglal egy puffert a helyi halomból, és felszabadítja azt az objektum megsemmisítésekor. Az archívum nem szabadít fel felhasználó által megadott puffert.

Megjegyzések

Az archívum létrehozása után nem módosíthatja ezt a specifikációt.

Az archívum bezárásáig nem használhat CFile műveleteket a fájl állapotának módosítására. Minden ilyen művelet rontja az archívum integritását. A szerializálás során bármikor elérheti a fájlmutató pozícióját úgy, hogy lekéri az archívum fájlobjektumát a GetFile tagfüggvényből, majd használja a függvényt CFile::GetPosition . A fájlmutató pozíciójának lekérése előtt fel kell hívnia CArchive::Flush a hívást.

példa

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

Kiüríti a pufferben fennmaradó adatokat, bezárja az archívumot, és leválasztja az archívumot a fájlról.

void Close();

Megjegyzések

Az archívumon további műveletek nem engedélyezettek. Az archívum bezárása után létrehozhat egy másik archívumot ugyanahhoz a fájlhoz, vagy bezárhatja a fájlt.

A tagfüggvény Close biztosítja, hogy az összes adat átkerüljön az archívumból a fájlba, és elérhetetlenné teszi az archívumot. A fájlról a tárolóeszközre történő átvitel befejezéséhez először használnia CFile::Close kell, majd el kell pusztítania az CFile objektumot.

példa

Lásd a CArchive::WriteString példát.

CArchive::Flush

Kényszeríti, hogy az archív pufferben lévő összes adat a fájlba legyen írva.

void Flush();

Megjegyzések

A tagfüggvény Flush biztosítja, hogy az összes adat átkerüljön az archívumból a fájlba. A fájlból a tároló adathordozóra történő átvitel befejezéséhez fel kell hívnia a hívást CFile::Close .

példa

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

Lekéri az CFile archívum objektummutatóját.

CFile* GetFile() const;

Visszaadott érték

Állandó mutató a CFile használt objektumra.

Megjegyzések

A használat GetFileelőtt ki kell ürítenie az archívumot.

példa

const CFile *fp = ar.GetFile();

CArchive::GetObjectSchema

Hívja meg ezt a függvényt a Serialize függvényből a jelenleg deszerializált objektum verziójának meghatározásához.

UINT GetObjectSchema();

Visszaadott érték

A deszerializálás során az éppen beolvasott objektum verziója.

Megjegyzések

A függvény meghívása csak akkor érvényes, ha az CArchive objektum be van töltve ( CArchive::IsLoading nemzero értéket ad vissza). Ez lehet a függvény első hívása Serialize , és csak egyszer hívható meg. A (UINT)-1 visszatérési értéke azt jelzi, hogy a verziószám ismeretlen.

A CObject-származtatott osztály VERSIONABLE_SCHEMA a sémaverzióval (a makróban|) együtt (bitenkénti "vagy" (IMPLEMENT_SERIAL)) használatával létrehozhat egy "verziózható objektumot", vagyis egy olyan objektumot, amelynek tagfüggvénye Serialize több verziót is képes olvasni. Az alapértelmezett keretrendszerfunkció (anélkül VERSIONABLE_SCHEMA) kivételt jelent, ha a verzió nem egyezik.

példa

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

Hívja meg ezt a tagfüggvényt annak megállapításához, hogy az archív objektum belső puffere üres-e.

BOOL IsBufferEmpty() const;

Visszaadott érték

Nonzero, ha az archívum puffere üres; egyéb esetben 0.

Megjegyzések

Ez a függvény az MFC Windows Sockets osztály CSocketFileprogramozásának támogatásához érhető el. Nem kell használnia egy objektumhoz CFile társított archívumhoz.

Az objektumhoz IsBufferEmpty társított archívum használatának okaCSocketFile, hogy az archívum puffere egynél több üzenetet vagy rekordot tartalmazhat. Egy üzenet fogadása után egy olyan hurkot kell IsBufferEmpty vezérelnie, amely addig fogad adatokat, amíg a puffer üres nem lesz. További információkért tekintse meg az Receive osztály CAsyncSockettagfüggvényét, amely a használat IsBufferEmptymódját mutatja be.

További információ : Windows-szoftvercsatornák: Szoftvercsatornák használata archívumokkal.

CArchive::IsLoading

Meghatározza, hogy az archívum betölti-e az adatokat.

BOOL IsLoading() const;

Visszaadott érték

Nonzero, ha az archívumot jelenleg betöltéshez használják; egyéb esetben 0.

Megjegyzések

Ezt a tagfüggvényt az Serialize archivált osztályok függvényei hívják meg.

példa

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

CArchive::IsStoring

Meghatározza, hogy az archívum tárolja-e az adatokat.

BOOL IsStoring() const;

Visszaadott érték

Nonzero, ha az archívumot jelenleg tárolásra használják; egyéb esetben 0.

Megjegyzések

Ezt a tagfüggvényt az Serialize archivált osztályok függvényei hívják meg.

Ha az IsStoring archívum állapota nem 0, akkor IsLoading az állapota 0, és fordítva.

példa

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

CArchive::MapObject

Hívja meg ezt a tagfüggvényt, hogy helyezzen el olyan objektumokat a térképen, amelyek valójában nem szerializáltak a fájlhoz, de amelyek az alobjektumok számára referenciaként elérhetők.

void MapObject(const CObject* pOb);

Paraméterek

pOb
Állandó mutató a tárolt objektumra.

Megjegyzések

Előfordulhat például, hogy nem szerializál egy dokumentumot, de szerializálná a dokumentum részét képező elemeket. A hívással MapObjectengedélyezheti, hogy ezek az elemek vagy alobjektumok hivatkozhassanak a dokumentumra. Emellett a szerializált részhalmazok szerializálhatják a hátsó mutatójukat m_pDocument .

Meghívhatja MapObject , amikor az objektumot tárolja és betölti CArchive . MapObject Hozzáadja a megadott objektumot az objektum által CArchive szerializálás és deszerializálás során karbantartott belső adatstruktúrákhoz, de ellentétben ReadObject az objektum szerializálásával, és WriteObjectnem hívja meg a szerializálást az objektumon.

példa

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

Alapértelmezés szerint ez a NULL mutató CDocument a példány felhasználója CArchive által kívánt értékre állítható be.

CDocument* m_pDocument;

Megjegyzések

Ennek a mutatónak a gyakori használata az, hogy a szerializálási folyamattal kapcsolatos további információkat továbbít az összes szerializált objektumnak. Ez úgy érhető el, hogy inicializálja az egérmutatót a szerializált dokumentummal (egy CDocument-származtatott osztály), oly módon, hogy a dokumentumon belüli objektumok szükség esetén hozzáférhessenek a dokumentumhoz. Ezt a mutatót COleClientItem az objektumok a szerializálás során is használják.

A keretrendszer a szerializált dokumentumra állítja be m_pDocument , amikor egy felhasználó fájlmegnyitási vagy mentési parancsot ad ki. Ha a fájlmegnyitástól vagy a mentéstől eltérő okból szerializál egy Objektum csatolása és beágyazása (OLE) tárolódokumentumot, explicit módon kell beállítania m_pDocument. Ezt például akkor teheti meg, ha tárolódokumentumot szerializál a vágólapra.

példa

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

A megadott objektumot vagy primitív típust az archívumban tárolja.

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

Visszaadott érték

Egy CArchive hivatkozás, amely több beszúrási operátort tesz lehetővé egy sorban.

Megjegyzések

A fenti két utolsó verzió kifejezetten 64 bites egész számok tárolására használható.

Ha a makrót az IMPLEMENT_SERIAL osztály implementációjában használta, akkor a beszúrási operátor túlterhelte a védett CObjecthívásokatWriteObject. Ez a függvény viszont meghívja az Serialize osztály függvényét.

A CStringT beszúrási operátor (<<) támogatja a diagnosztikai memóriaképezést és az archívumba való tárolást.

Példák

Ez a példa a beszúrási CArchive operátor << és int a long típusok használatát mutatja be.

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

Ez a példa a beszúrási CArchive operátor << típussal való CStringT használatát mutatja be.

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

CArchive::operator >>

Betölti a megadott objektumot vagy primitív típust az archívumból.

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

Visszaadott érték

Egy CArchive hivatkozás, amely több extrakciós operátort tesz lehetővé egyetlen sorban.

Megjegyzések

A fenti két utolsó verzió kifejezetten a 64 bites egész számok betöltésére használható.

Ha a makrót az IMPLEMENT_SERIAL osztály implementációjában használta, akkor az extrakciós operátorok túlterheltek a védett CObject függvény meghívásához ReadObject (nemero futásidejű osztálymutatóval). Ez a függvény viszont meghívja az Serialize osztály függvényét.

A CStringT kinyerési operátor (>>) támogatja az archívumból való betöltést.

Példák

Ez a példa a kinyerési CArchive operátor >> típussal való int használatát mutatja be.

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

Ez a példa bemutatja a beszúrási CArchive és kinyerési operátorok << használatát, valamint >> a típust CStringT .

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

CArchive::Read

Megadott számú bájtot olvas be az archívumból.

UINT Read(void* lpBuf, UINT nMax);

Paraméterek

lpBuf
A felhasználó által megadott pufferre mutató mutató, amely az archívumból beolvasott adatokat fogadja.

nMax
Egy aláíratlan egész szám, amely megadja az archívumból beolvasandó bájtok számát.

Visszaadott érték

Egy aláíratlan egész szám, amely a ténylegesen beolvasott bájtok számát tartalmazza. Ha a visszaadott érték kisebb, mint a kért szám, a fájl vége el lett érve. A fájlvégi feltétel nem kivétel.

Megjegyzések

Az archívum nem értelmezi a bájtokat.

A függvény tagfüggvényét használhatja Read az Serialize objektumokban található szokásos struktúrák olvasására.

példa

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

CArchive::ReadClass

Hívja meg ezt a tagfüggvényt, hogy beolvasszon egy korábban tárolt WriteClassosztályra mutató hivatkozást.

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

Paraméterek

pClassRefRequested
A kért osztályhivatkozásnak megfelelő struktúra mutatója CRuntimeClass . Lehet NULL.

pSchema
A korábban tárolt futásidejű osztály sémájára mutató mutató.

pObTag
Egy objektum egyedi címkéjére hivatkozó szám. Belsőleg a végrehajtás során használják ReadObject. Csak speciális programozáshoz érhető el; pObTag általában .NULL

Visszaadott érték

A szerkezetre mutató CRuntimeClass mutató.

Megjegyzések

Ha pClassRefRequested nem NULL, ellenőrzi, ReadClass hogy az archivált osztályadatok kompatibilisek-e a futtatókörnyezeti osztálysal. Ha nem kompatibilis, ReadClass egy CArchiveException.

A futtatókörnyezeti osztálynak használnia DECLARE_SERIAL kell, IMPLEMENT_SERIAL és ReadClassellenkező esetben egy CNotSupportedException.

Ha pSchema igen NULL, a tárolt osztály sémája hívással CArchive::GetObjectSchemakérhető le; *pSchema ellenkező esetben a korábban tárolt futásidejű osztály sémáját fogja tartalmazni.

SerializeClass Használhatja ReadClassahelyett, hogy az osztályhivatkozás olvasását és írását is kezeli.

példa

Lásd a példát a CArchive::WriteClass.

CArchive::ReadObject

Beolvassa az objektumadatokat az archívumból, és létrehoz egy megfelelő típusú objektumot.

CObject* ReadObject(const CRuntimeClass* pClass);

Paraméterek

pClass
Állandó mutató az CRuntimeClass olvasni kívánt objektumnak megfelelő struktúrára.

Visszaadott érték

Olyan CObject mutató, amelyet biztonságosan kell a megfelelő származtatott osztályba illeszteni a használatával CObject::IsKindOf.

Megjegyzések

Ezt a függvényt általában a CArchive mutatóhoz >> túlterhelt extrakciós (CObject) operátor hívja meg. ReadObject, viszont meghívja az Serialize archivált osztály függvényét.

Ha egy nemzero pClass paramétert ad meg, amelyet a RUNTIME_CLASS makró szerez be, akkor a függvény ellenőrzi az archivált objektum futásidejű osztályát. Ez azt feltételezi, hogy a makrót IMPLEMENT_SERIAL az osztály implementációjában használta.

példa

Lásd a példát a CArchive::WriteObject.

CArchive::ReadString

Hívja meg ezt a tagfüggvényt, hogy szöveges adatokat olvasson be egy pufferbe az CArchive objektumhoz társított fájlból.

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

Paraméterek

rString
Az objektumhoz CString társított fájlból való beolvasás után az eredményül kapott sztringet tartalmazó hivatkozásCArchive.

lpsz
A felhasználó által megadott pufferre mutató mutatót ad meg, amely null értékű szöveges sztringet fog kapni.

nMax
Meghatározza az elolvasandó karakterek maximális számát. Egy kisebbnek kell lennie, mint a lpsz puffer mérete.

Visszaadott érték

A BOOL-t visszaadó verzióban, ha sikeres; TRUEFALSE ellenkező esetben.

Abban a verzióban, amely egy LPTSTR, a szöveges adatokat tartalmazó pufferre mutató mutatót ad vissza; NULL ha a fájl vége el lett érve.

Megjegyzések

A paraméterrel rendelkező nMax tagfüggvény verziójában a puffer legfeljebb 1 karakter hosszúságú korlátot nMax tartalmazhat. Az olvasást egy kocsivisszaúti betáplálási pár leállítja. A záró újsoros karakterek mindig törlődnek. A program mindkét esetben hozzáfűz egy NULL karaktert ('\0').

CArchive::Read szöveg módú bemenethez is elérhető, de nem végződik visszaútvonalas kocsiadagoló páron.

példa

Lásd a példát a CArchive::WriteString.

CArchive::SerializeClass

Hívja meg ezt a tagfüggvényt, ha egy alaposztály verzióadatait szeretné tárolni és betölteni.

void SerializeClass(const CRuntimeClass* pClassRef);

Paraméterek

pClassRef
Az alaposztály futásidejű osztályobjektumára mutató mutató.

Megjegyzések

SerializeClassaz objektum irányától függően CArchivebeolvassa vagy megírja az CArchive osztályra mutató hivatkozást. Alaposztályú SerializeClass objektumok ReadClass szerializálása WriteClass helyett és SerializeClass kényelmesen használható; kevesebb kódot és kevesebb paramétert igényel.

Például ReadClassellenőrzi, SerializeClass hogy az archivált osztályadatok kompatibilisek-e a futtatókörnyezeti osztálysal. Ha nem kompatibilis, SerializeClass egy CArchiveException.

A futtatókörnyezeti osztálynak használnia DECLARE_SERIAL kell, IMPLEMENT_SERIAL és SerializeClassellenkező esetben egy CNotSupportedException.

A makróval RUNTIME_CLASS lekérheti a pRuntimeClass paraméter értékét. Az alaposztálynak a makrót kellett használnia IMPLEMENT_SERIAL .

példa

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

Hívás SetLoadParams , amikor nagy számú CObject- származtatott objektumot fog olvasni egy archívumból.

void SetLoadParams(UINT nGrowBy = 1024);

Paraméterek

nGrowBy
A lefoglalandó elemhelyek minimális száma, ha méretnövelésre van szükség.

Megjegyzések

CArchive egy betöltési tömb használatával oldja fel az archívumban tárolt objektumokra mutató hivatkozásokat. SetLoadParams lehetővé teszi a terhelési tömb méretének beállítását.

A rendszer nem hívhatja SetLoadParams meg az objektumokat a betöltés, illetve a hívás után MapObject vagy ReadObject után.

példa

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

Hívja meg ezt a tagfüggvényt az archív objektumban tárolt objektumséma beállításához nSchema.

void SetObjectSchema(UINT nSchema);

Paraméterek

nSchema
Megadja az objektum sémáját.

Megjegyzések

A következő hívás a következőben GetObjectSchema tárolt nSchemaértéket adja vissza.

Speciális verziószámozáshoz használható SetObjectSchema , például ha egy adott verzió olvasását szeretné kikényszeríteni egy származtatott osztály függvényében Serialize .

példa

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

CArchive::SetStoreParams

Nagy számú SetStoreParams-származtatott objektum archívumban való tárolására használhatóCObject.

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

Paraméterek

nHashSize
Az illesztőmutató-térképek kivonattáblájának mérete. Prímszámnak kell lennie.

nBlockSize
Megadja a paraméterek kiterjesztésének memóriafoglalási részletességét. A legjobb teljesítmény érdekében 2-nek kell lennie.

Megjegyzések

SetStoreParams Lehetővé teszi a kivonattábla méretének és a térkép blokkméretének beállítását, amely egyedi objektumok azonosítására szolgál a szerializálási folyamat során.

A rendszer nem hívhatja SetStoreParams meg az objektumokat a tárolás, illetve a meghívás után MapObject vagy WriteObject után.

példa

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

Megadott számú bájtot ír az archívumba.

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

Paraméterek

lpBuf
Mutató egy felhasználó által megadott pufferre, amely az archívumba írandó adatokat tartalmazza.

nMax
Az archívumba írandó bájtok számát meghatározó egész szám.

Megjegyzések

Az archívum nem formázza a bájtokat.

A függvény tagfüggvényét Write használhatja Serialize az objektumokban található szokásos struktúrák írására.

példa

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

CArchive::WriteClass

Az alaposztály verzió- és osztályinformációinak tárolására szolgál WriteClass a származtatott osztály szerializálása során.

void WriteClass(const CRuntimeClass* pClassRef);

Paraméterek

pClassRef
A kért osztályhivatkozásnak megfelelő struktúra mutatója CRuntimeClass .

Megjegyzések

WriteClass az alaposztályra mutató hivatkozást CRuntimeClass ír a CArchive. A hivatkozás lekérésére szolgál CArchive::ReadClass .

WriteClass ellenőrzi, hogy az archivált osztályadatok kompatibilisek-e a futtatókörnyezeti osztálysal. Ha nem kompatibilis, WriteClass egy CArchiveException.

A futtatókörnyezeti osztálynak használnia DECLARE_SERIAL kell, IMPLEMENT_SERIAL és WriteClassellenkező esetben egy CNotSupportedException.

SerializeClass Használhatja WriteClassahelyett, hogy az osztályhivatkozás olvasását és írását is kezeli.

példa

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

Tárolja a megadott CObject adatokat az archívumban.

void WriteObject(const CObject* pOb);

Paraméterek

pOb
Állandó mutató a tárolt objektumra.

Megjegyzések

Ezt a függvényt általában a CArchive beszúrási (<<) operátor hívja meg.CObject WriteObject, viszont meghívja az Serialize archivált osztály függvényét.

Az archiválás engedélyezéséhez a IMPLEMENT_SERIAL makrót kell használnia. WriteObject az ASCII-osztály nevét az archívumba írja. Ezt az osztálynevet később érvényesíti a rendszer a betöltési folyamat során. Egy speciális kódolási séma megakadályozza az osztály nevének szükségtelen duplikálását az osztály több objektuma esetében. Ez a séma azt is megakadályozza, hogy egynél több mutatót célként szolgáló objektumok redundáns tárolása.

A pontos objektumkódolási módszer (beleértve az ASCII-osztálynév jelenlétét) implementálási részlet, és a kódtár későbbi verzióiban változhat.

Megjegyzés:

Mielőtt elkezdené archiválni őket, fejezze be az összes objektum létrehozását, törlését és frissítését. Az archiválás sérült lesz, ha az archiválást objektummódosítással keveri.

példa

Az osztály CAgedefinícióját lásd a példában 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

Ezzel a tagfüggvénnyel adatokat írhat egy pufferből az CArchive objektumhoz társított fájlba.

void WriteString(LPCTSTR lpsz);

Paraméterek

lpsz
Null értékű szöveges sztringet tartalmazó pufferre mutató mutatót ad meg.

Megjegyzések

A megszüntető null karakter ('\0') nincs megírva a fájlba; nem ír automatikusan új vonalat.

WriteString kivételt jelez több feltételre válaszul, beleértve a lemez teljes állapotát is.

Write is elérhető, de ahelyett, hogy null karakterre végződik, a kért bájtszámot írja a fájlba.

példa

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

Lásd még

hierarchiadiagram
CFile osztály
CObject osztály
CSocket osztály
CSocketFile osztály

  • Last updated on