Not
Åtkomst till den här sidan kräver auktorisering. Du kan prova att logga in eller ändra kataloger.
Åtkomst till den här sidan kräver auktorisering. Du kan prova att ändra kataloger.
CFile-härledd klass som stöder minnesfiler.
Syntax
class CMemFile : public CFile
Medlemmar
Offentliga konstruktorer
| Namn | Beskrivning |
|---|---|
| CMemFile::CMemFile | Konstruerar ett minnesfilobjekt. |
Offentliga metoder
| Namn | Beskrivning |
|---|---|
| CMemFile::Attach | Kopplar ett minnesblock till CMemFile. |
| CMemFile::D etach | Kopplar bort minnesblocket från CMemFile och returnerar en pekare till det minnesblock som kopplas från. |
| CMemFile::GetBufferPtr | Hämta eller skriv till minnesbufferten som säkerhetskopierar en minnesfil. |
Skyddade metoder
| Namn | Beskrivning |
|---|---|
| CMemFile::Alloc | Åsidosätt för att ändra beteende för minnesallokering. |
| CMemFile::Free | Åsidosätt för att ändra beteendet för frigöring av minne. |
| CMemFile::GrowFile | Åsidosätt för att ändra beteende när du odlar en fil. |
| CMemFile::Memcpy | Åsidosätt för att ändra minneskopieringsbeteende när du läser och skriver filer. |
| CMemFile::Realloc | Åsidosätt för att ändra beteendet för omfördelning av minne. |
Anmärkningar
Dessa minnesfiler fungerar som diskfiler förutom att filen lagras i RAM-minne i stället för på disk. En minnesfil är användbar för:
- snabb tillfällig lagring
- överföra råa byte mellan oberoende processer
- överföra serialiserade objekt mellan oberoende processer
CMemFile objekt kan automatiskt allokera sitt eget minne. Eller så kan du koppla ditt eget minnesblock till objektet genom att CMemFile anropa Bifoga. I båda fallen allokeras minne för att växa minnesfilen automatiskt i nGrowBytes-size-steg om nGrowBytes inte är noll.
Minnesblocket tas automatiskt bort när objektet förstörs CMemFile om minnet ursprungligen allokerades av CMemFile objektet. Annars ansvarar du för att frigöra det minne som du har kopplat till objektet.
Du kan komma åt minnesblocket via pekaren som anges när du kopplar bort det från CMemFile objektet genom att anropa Koppla från.
Den vanligaste användningen av CMemFile är att skapa ett CMemFile objekt och använda det genom att anropa CFile-medlemsfunktioner . När du skapar en CMemFile öppnas den automatiskt: du anropar inte CFile::Open, som endast används för diskfiler. Eftersom CMemFile inte använder en diskfil används inte datamedlemmen CFile::m_hFile .
Medlemsfunktionerna CFileDuplicera, LåsRange och UnlockRange implementeras inte för CMemFile. Om du anropar dessa funktioner på ett CMemFile objekt får du en CNotSupportedException.
CMemFile använder körningsbiblioteksfunktionerna malloc, realloc och free för att allokera, omallokera och frigöra minne. och den inbyggda memcpy för att blockera kopiera minne när du läser och skriver. Om du vill ändra det här beteendet eller beteendet när CMemFile en fil växer, härleder du din egen klass från CMemFile och åsidosätter lämpliga funktioner.
Mer information om CMemFilefinns i artiklarna Filer i MFC och Minneshantering (MFC) och se Filhantering i Run-Time-biblioteksreferensen.
Arvshierarki
CMemFile
Kravspecifikation
rubrik: afx.h
CMemFile::Alloc
Den här funktionen anropas av CMemFile medlemsfunktioner.
virtual BYTE* Alloc(SIZE_T nBytes);
Parameterar
nByte
Antal byte minne som ska allokeras.
Returvärde
En pekare till det minnesblock som allokerades eller NULL om allokeringen misslyckades.
Anmärkningar
Åsidosätt den här funktionen för att implementera anpassad minnesallokering. Om du åsidosätter den här funktionen vill du förmodligen också åsidosätta Kostnadsfri och Omlokal .
Standardimplementeringen använder funktionen malloc för körningsbiblioteket för att allokera minne.
CMemFile::Attach
Anropa den här funktionen för att koppla ett minnesblock till CMemFile.
void Attach(
BYTE* lpBuffer,
UINT nBufferSize,
UINT nGrowBytes = 0);
Parameterar
lpBuffer
Pekare till bufferten som ska kopplas till CMemFile.
nBufferSize
Ett heltal som anger storleken på bufferten i byte.
nGrowBytes
Ökning av minnesallokering i byte.
Anmärkningar
Detta gör CMemFile att minnesblocket används som minnesfil.
Om nGrowBytes är 0 CMemFile anger du fillängden till nBufferSize. Det innebär att data i minnesblocket innan de kopplades till CMemFile används som fil. Minnesfiler som skapats på det här sättet kan inte odlas.
Eftersom filen inte kan odlas bör du vara försiktig så att du inte försöker CMemFile utöka filen. Anropa CMemFile till exempel inte åsidosättningarna för CFile::Skriv för att skriva förbi slutet eller anropa inte CFile::SetLength med en längd som är längre än nBufferSize.
Om nGrowBytes är större än 0 CMemFile ignoreras innehållet i det minnesblock som du har kopplat. Du måste skriva innehållet i minnesfilen från grunden med hjälp av åsidosättningen CMemFile av CFile::Write. Om du försöker skriva efter slutet av filen eller utöka filen genom att anropa åsidosättningen CMemFile av CFile::SetLength, CMemFile ökar minnesallokeringen i steg om nGrowBytes. Det går inte att öka minnesallokeringen om det minnesblock som du skickar till Attach inte allokerats med en metod som är kompatibel med Alloc. För att vara kompatibel med standardimplementeringen av Allocmåste du allokera minnet med funktionen malloc eller calloc för körningsbiblioteksfunktionen.
CMemFile::CMemFile
Den första överlagringen öppnar en tom minnesfil.
CMemFile(UINT nGrowBytes = 1024);
CMemFile(
BYTE* lpBuffer,
UINT nBufferSize,
UINT nGrowBytes = 0);
Parameterar
nGrowBytes
Ökning av minnesallokering i byte.
lpBuffer
Pekare till en buffert som tar emot information om storleken nBufferSize.
nBufferSize
Ett heltal som anger filbuffertens storlek i byte.
Anmärkningar
Filen öppnas av konstruktorn. Anropa inte CFile::Open.
Den andra överlagringen fungerar på samma sätt som om du använde den första konstruktorn och anropade omedelbart Bifoga med samma parametrar. Se Attach för mer information.
Exempel
CMemFile f; // Ready to use - no Open necessary.
BYTE * pBuf = (BYTE *)new char [1024];
CMemFile g(pBuf, 1024, 256);
// same as CMemFile g; g.Attach(pBuf, 1024, 256);
CMemFile::D etach
Anropa den här funktionen för att hämta en pekare till minnesblocket som används av CMemFile.
BYTE* Detach();
Returvärde
En pekare till minnesblocket som innehåller innehållet i minnesfilen.
Anmärkningar
Om du anropar CMemFileden här funktionen stängs även . Du kan koppla minnesblocket till igen genom att CMemFile anropa Anslut. Om du vill koppla om filen och använda data i den bör du anropa CFile::GetLength för att hämta filens längd innan du anropar Detach. Om du kopplar ett minnesblock till CMemFile så att du kan använda dess data (nGrowBytes == 0) kan du inte utöka minnesfilen.
CMemFile::Free
Den här funktionen anropas av CMemFile medlemsfunktioner.
virtual void Free(BYTE* lpMem);
Parameterar
lpMem
Pekare till minnet som ska frigöras.
Anmärkningar
Åsidosätt den här funktionen för att implementera anpassad minnesallokering. Om du åsidosätter den här funktionen vill du förmodligen också åsidosätta Alloc och Realloc .
CMemFile::GetBufferPtr
Hämta eller skriv till minnesbufferten som säkerhetskopierar en minnesfil.
virtual UINT GetBufferPtr(
UINT nCommand,
UINT nCount = 0,
void** ppBufStart = NULL,
void** ppBufMax = NULL
);
Parameterar
nCommand
BufferCommand att utföra (bufferCheck, , bufferCommitbufferRead, eller bufferWrite).
nCount
Beroende på nCommand, antalet byte i bufferten för att läsa, skriva eller checka in. När du läser från bufferten anger du -1 för att returnera en buffert från den aktuella positionen till slutet av filen.
ppBufStart
[ut] Början av bufferten. Måste vara NULL när nCommand är bufferCommit.
ppBufMax
[ut] Buffertens slut. Måste vara NULL när nCommand är bufferCommit.
Returvärde
| kommandovärde | Returvärde |
|---|---|
buffercheck |
Returnerar bufferDirect om direkt buffring stöds, annars 0. |
bufferCommit |
Returnerar 0 |
bufferRead eller bufferWrite |
Returnerar antalet byte i det returnerade buffertutrymmet. ppBufStart och ppBufMax pekar på början och slutet av den läs-/skrivskyddade bufferten. |
Anmärkningar
Den aktuella positionen i minnesbufferten (m_nPosition) är avancerad på följande sätt, beroende på nKommando:
| nCommand | buffertposition |
|---|---|
bufferCommit |
Den aktuella positionen avancerar efter storleken på den incheckade bufferten. |
bufferRead |
Den aktuella positionen ökar med läsbuffertens storlek. |
CMemFile::GrowFile
Den här funktionen anropas av flera av medlemsfunktionerna CMemFile .
virtual void GrowFile(SIZE_T dwNewLen);
Parameterar
dwNewLen
Ny storlek på minnesfilen.
Anmärkningar
Du kan åsidosätta den om du vill ändra hur CMemFile filen växer. Standardimplementeringen anropar Realloc för att utöka ett befintligt block (eller Alloc för att skapa ett minnesblock), allokera minne i multiplar av det nGrowBytes värde som anges i konstruktorn eller Bifoga anropet.
CMemFile::Memcpy
Den här funktionen anropas av CMemFile åsidosättningarna för CFile::Read och CFile::Write för att överföra data till och från minnesfilen.
virtual BYTE* Memcpy(
BYTE* lpMemTarget,
const BYTE* lpMemSource,
SIZE_T nBytes);
Parameterar
lpMemTarget
Pekare till minnesblocket som källminnet ska kopieras till.
lpMemSource
Pekare till källminnesblocket.
nByte
Antal byte som ska kopieras.
Returvärde
En kopia av lpMemTarget.
Anmärkningar
Åsidosätt den här funktionen om du vill ändra hur CMemFile dessa minneskopior ska utföras.
CMemFile::Realloc
Den här funktionen anropas av CMemFile medlemsfunktioner.
virtual BYTE* Realloc(
BYTE* lpMem,
SIZE_T nBytes);
Parameterar
lpMem
En pekare till minnesblocket som ska omallokeras.
nByte
Ny storlek för minnesblocket.
Returvärde
En pekare till minnesblocket som omallokerades (och eventuellt flyttades) eller NULL om omfördelningen misslyckades.
Anmärkningar
Åsidosätt den här funktionen för att implementera omallokering av anpassat minne. Om du åsidosätter den här funktionen vill du förmodligen åsidosätta Även Alloc och Free .