`fopen`, `_wfopen`

Artikel
2025-03-22

Öppnar en fil. Säkrare versioner av dessa funktioner som utför mer parametervalidering och returfelkoder är tillgängliga. se fopen_s, _wfopen_s.

Syntax

FILE *fopen(
   const char *filename,
   const char *mode
);
FILE *_wfopen(
   const wchar_t *filename,
   const wchar_t *mode
);

Parameterar

filename
Filnamn.

mode
Typ av åtkomst som är aktiverad.

Returvärde

Var och en av dessa funktioner returnerar en pekare till den öppna filen. Ett null-pekarvärde anger ett fel. Om filename eller mode är NULL eller en tom sträng utlöser dessa funktioner den ogiltiga parameterhanteraren, som beskrivs i Parameterverifiering. Om körningen tillåts fortsätta returnerar dessa funktioner NULL och anger errno till EINVAL.

Mer information finns i errno, _doserrno, _sys_errlistoch _sys_nerr.

Anmärkningar

Funktionen fopen öppnar filen som anges av filename. Som standard tolkas en smal filename sträng med hjälp av ANSI-kodsidan (CP_ACP). I Windows Desktop-program kan den ändras till OEM-kodsidan (CP_OEMCP) med hjälp av funktionen SetFileApisToOEM. Du kan använda funktionen AreFileApisANSI för att avgöra om filename tolkas med hjälp av ANSI eller oem-standardkodsidan för systemet. _wfopen är en bred teckenversion av fopen; de _wfopen argumenten är strängar med breda tecken. Annars fungerar _wfopen och fopen på samma sätt. Att bara använda _wfopen påverkar inte den kodade teckenuppsättningen som används i filströmmen.

fopen accepterar sökvägar som är giltiga i filsystemet vid körningspunkten. fopen accepterar UNC-sökvägar och sökvägar som omfattar mappade nätverksenheter så länge systemet som kör koden har åtkomst till resursen eller den mappade enheten vid tidpunkten för körningen. När du skapar sökvägar för fopenkontrollerar du att enheter, sökvägar eller nätverksresurser är tillgängliga i körningsmiljön. Du kan använda antingen snedstreck (/) eller omvänt snedstreck (\) som katalogavgränsare i en sökväg.

Kontrollera alltid returvärdet för att se om pekaren är NULL innan du utför några andra åtgärder i filen. Om ett fel inträffar anges den globala variabeln errno och kan användas för att hämta specifik felinformation. Mer information finns i errno, _doserrno, _sys_errlistoch _sys_nerr.

Som standard är den här funktionens globala tillstånd begränsat till programmet. Information om hur du ändrar det finns i Globalt tillstånd i CRT-.

Unicode-stöd

fopen stöder Unicode-filströmmar. Om du vill öppna en Unicode-fil skickar du en ccs=encoding flagga som anger önskad kodning till fopen, enligt följande.

FILE *fp = fopen("newfile.txt", "rt+, ccs=UTF-8");

Tillåtna värden för ccs kodning är UNICODE, UTF-8och UTF-16LE.

När en fil öppnas i Unicode-läge översätter indatafunktionerna de data som läses från filen till UTF-16-data som lagras som typ wchar_t. Funktioner som skriver till en fil som öppnas i Unicode-läge förväntar sig buffertar som innehåller UTF-16-data som lagras som typ wchar_t. Om filen kodas som UTF-8 översätts UTF-16-data till UTF-8 när den skrivs. Filens UTF-8-kodade innehåll översätts till UTF-16 när den läses. Ett försök att läsa eller skriva ett udda antal byte i Unicode-läge orsakar ett parameterverifiering fel. Om du vill läsa eller skriva data som lagras i programmet som UTF-8 använder du ett text- eller binärfilläge i stället för ett Unicode-läge. Du ansvarar för all nödvändig kodningsöversättning.

Om filen redan finns och öppnas för att läsas eller läggs till avgör alla byteordningsmarkeringar (BOM) i filen kodningen. BOM-kodningen har företräde framför den kodning som anges av flaggan ccs. Den ccs kodningen används bara när ingen strukturliste finns eller om filen är en ny fil.

Anmärkning

Bomidentifiering gäller endast för filer som öppnas i Unicode-läge (det vill: genom att skicka flaggan ccs).

I följande tabell sammanfattas de lägen som används för olika ccs flaggor som ges till fopen och Byte Order Marks i filen.

Kodningar som används baserat på ccs-flagga och BOM

`ccs` flagga	Ingen strukturlista (eller ny fil)	BOM: UTF-8	BOM: UTF-16
`UNICODE`	`UTF-16LE`	`UTF-8`	`UTF-16LE`
`UTF-8`	`UTF-8`	`UTF-8`	`UTF-16LE`
`UTF-16LE`	`UTF-16LE`	`UTF-8`	`UTF-16LE`

Filer som öppnas för skrivning i Unicode-läge har en strukturlista som skrivs till dem automatiskt.

Om mode är a, ccs=encoding för något encoding värde försöker fopen först öppna filen med hjälp av både läs- och skrivåtkomst. Om den här åtgärden lyckas läser funktionen bommen för att fastställa kodningen för filen. Om det misslyckas använder funktionen standardkodningen för filen. I båda fallen öppnar fopen filen igen med skrivskyddad åtkomst. (Det här beteendet gäller endast för "a" läge, inte för "a+" läge.)

Allmän textrutinmappning

`TCHAR.H` rutin	`_UNICODE` och `_MBCS` inte definierat	`_MBCS` definierad	`_UNICODE` definierad
`_tfopen`	`fopen`	`fopen`	`_wfopen`

Teckensträngen mode anger vilken typ av åtkomst som begärs för filen enligt följande.

`mode`	Åtkomst
`"r"`	Öppnas för läsning. Om filen inte finns eller inte kan hittas misslyckas `fopen`-anropet.
`"w"`	Öppnar en tom fil för skrivning. Om den angivna filen finns förstörs dess innehåll.
`"a"`	Öppnas för skrivning i slutet av filen (väntar) utan att ta bort EOF-markören (end-of-file) innan nya data skrivs till filen. Skapar filen om den inte finns.
`"r+"`	Öppnar för både läsning och skrivning. Filen måste finnas.
`"w+"`	Öppnar en tom fil för både läsning och skrivning. Om filen finns förstörs dess innehåll.
`"a+"`	Öppnar för att läsa och lägga till. Den väntande åtgärden omfattar borttagning av EOF-markören innan nya data skrivs till filen. EOF-markören återställs inte när skrivning har slutförts. Skapar filen om den inte finns.

När en fil öppnas med hjälp av "a" åtkomsttyp eller "a+" åtkomsttyp sker alla skrivåtgärder i slutet av filen. Filpekaren kan flyttas med hjälp av fseek eller rewind, men flyttas alltid tillbaka till slutet av filen innan någon skrivåtgärd utförs. Därför kan befintliga data inte skrivas över.

Det "a" läget tar inte bort EOF-markören innan den läggs till i filen. När du har lagt till har inträffat visar kommandot MS-DOS TYPE endast data upp till den ursprungliga EOF-markören och inga data som läggs till i filen. Innan den läggs till i filen tar "a+"-läget bort EOF-markören. När du har lagt till kommandot MS-DOS TYPE visas alla data i filen. Det "a+" läget krävs för att lägga till en dataströmfil som avslutas med CTRL+Z EOF-markör.

När "r+", "w+"eller "a+" åtkomsttyp har angetts aktiveras både läsning och skrivning (filen sägs vara öppen för "uppdatering"). Men när du växlar från läsning till skrivning måste indataåtgärden stöta på en EOF-markör. Om det inte finns någon EOF måste du använda ett mellanliggande anrop till en filpositioneringsfunktion. Filplaceringsfunktionerna är fsetpos, fseekoch rewind. När du växlar från att skriva till att läsa måste du använda ett mellanliggande anrop till antingen fflush eller till en filplaceringsfunktion.

Förutom de tidigare värdena kan följande tecken läggas till i mode för att ange översättningsläget för nya radtecken.

`mode` modifierare	Översättningsläge
`t`	Öppna i textläge (översatt). Vagnreturlinjematning (CR-LF) kombinationer översätts till enradsfeeds (LF) på indata och LF-tecken översätts till CR-LF kombinationer av utdata. Dessutom tolkas CTRL+Z som ett filsluttecken vid indata.
`b`	Öppna i binärt (oöversatt) läge; översättningar som rör vagnretur och radmatningstecken ignoreras.

I textläge tolkas CTRL+Z- som ett EOF-tecken vid indata. I filer som öppnas för läsning/skrivning med hjälp av "a+"söker fopen efter en CTRL+Z- i slutet av filen och tar bort den, om det är möjligt. Den tas bort eftersom användning av fseek och ftell för att flytta i en fil som slutar med CTRL+Z kan leda till att fseek beter sig felaktigt nära slutet av filen.

I textläge översätts crlf-kombinationer (vagnreturradsmatning) till LF-tecken (single line feed) vid indata och LF-tecken översätts till CRLF-kombinationer vid utdata. När en Unicode stream-I/O-funktion fungerar i textläge (standard) antas käll- eller målströmmen vara en sekvens med flerabytestecken. Därför konverterar Unicode stream-input-funktionerna flerabytestecken till breda tecken (som vid ett anrop till funktionen mbtowc). Av samma anledning konverterar Unicode-strömutdatafunktionerna breda tecken till flerbytestecken (som vid ett anrop till funktionen wctomb).

Om t eller b inte anges i modedefinieras standardöversättningsläget av den globala variabeln _fmode. Om t eller b är prefix för argumentet misslyckas funktionen och returnerar NULL.

Mer information om hur du använder text- och binärlägen i Unicode och stream-I/O i flerabyte finns i text- och binärlägesfil I/O och Unicode stream I/O i text- och binärlägen.

Följande alternativ kan läggas till i mode för att ange fler beteenden.

`mode` modifierare	Uppförande
`x`	Tvingar funktionen att misslyckas om `filename` redan finns. Kan endast användas med "w" eller "w+"-specificerare.
`c`	Aktivera incheckningsflaggan för den associerade `filename` så att innehållet i filbufferten skrivs direkt till disken om antingen `fflush` eller `_flushall` anropas.
`n`	Återställ incheckningsflaggan för den associerade `filename` till "no-commit". Den här flaggan är standard. Den åsidosätter också den globala incheckningsflaggan om du länkar programmet till COMMODE.OBJ. Standardvärdet för global incheckningsflagga är "no-commit" såvida du inte uttryckligen länkar programmet till COMMODE. OBJ (se Länkalternativ).
`N`	Anger att filen inte ärvs av underordnade processer.
`S`	Anger att cachelagring är optimerat för, men inte begränsat till, sekventiell åtkomst från disk.
`R`	Anger att cachelagring är optimerat för, men inte begränsat till, slumpmässig åtkomst från disk.
`T`	Anger en fil som inte skrivs till disk om inte minnesbelastningen kräver det.
`D`	Anger en temporär fil som tas bort när den sista filpekaren till den stängs.
`ccs=encoding`	Anger det kodade tecken som ska användas (en av `UTF-8`, `UTF-16LE`eller `UNICODE`) för den här filen. Lämna ospecificerad om du vill ha ANSI-kodning. Den här flaggan är skild från flaggor som föregår den med kommatecken (`,`). Till exempel: `FILE *f = fopen("newfile.txt", "rt+, ccs=UTF-8");`

Giltiga tecken för den mode sträng som används i fopen och _fdopen motsvarar oflag argument som används i _open och _sopen, enligt följande.

Tecken i `mode` sträng	Motsvarande `oflag` värde för `_open`/`_sopen`
`a`	`_O_WRONLY \| _O_APPEND` (vanligtvis `_O_WRONLY \| _O_CREAT \| _O_APPEND`)
`a+`	`_O_RDWR \| _O_APPEND` (vanligtvis `_O_RDWR \| _O_APPEND \| _O_CREAT` )
`r`	`_O_RDONLY`
`r+`	`_O_RDWR`
`w`	`_O_WRONLY` (vanligtvis `_O_WRONLY \| _O_CREAT \| _O_TRUNC`)
`w+`	`_O_RDWR` (vanligtvis `_O_RDWR \| _O_CREAT \| _O_TRUNC`)
`b`	`_O_BINARY`
`t`	`_O_TEXT` (översatt)
`x`	`_O_EXCL`
`c`	Ingen
`n`	Ingen
`N`	`_O_NOINHERIT`
`S`	`_O_SEQUENTIAL`
`R`	`_O_RANDOM`
`T`	`_O_SHORTLIVED`
`D`	`_O_TEMPORARY`
`ccs=UNICODE`	`_O_WTEXT`
*`ccs=UTF-8`*	`_O_UTF8`
`ccs=UTF-16LE`	`_O_UTF16`

Om du använder rb läge behöver du inte portera koden, och om du förväntar dig att läsa de flesta av en stor fil eller inte bryr dig om nätverksprestanda kan du även överväga om du vill använda minnesmappade Win32-filer som ett alternativ.

Angående T och D:

T undviker att skriva filen till disk så länge minnesbelastningen inte kräver det. Mer information finns i FILE_ATTRIBUTE_TEMPORARY i Filattributkonstanter, och även det här blogginlägget Det är bara tillfälligt.
D anger en vanlig fil som skrivs till disk. Skillnaden är att den tas bort automatiskt när den stängs. Du kan kombinera TD för att få båda semantiken.

Alternativen c, n, R, S, t, Toch Dmode är Microsoft-tillägg för fopen och _wfopen och bör inte användas när du vill ha ANSI-portabilitet.

Krav

Funktion	Obligatoriskt huvud
`fopen`	`<stdio.h>`
`_wfopen`	`<stdio.h>` eller `<wchar.h>`

_wfopen är ett Microsoft-tillägg. Mer information om kompatibilitet finns i Compatibility.

Alternativen c, n, t, S, R, Toch Dmode är Microsoft-tillägg för fopen och _fdopen och bör inte användas där ANSI-portabilitet önskas.

Exempel 1

Följande program öppnar två filer. Den använder fclose för att stänga den första filen och _fcloseall för att stänga alla återstående filer.

// crt_fopen.c
// compile with: /W3
// This program opens two files. It uses
// fclose to close the first file and
// _fcloseall to close all remaining files.

#include <stdio.h>

FILE *stream, *stream2;

int main( void )
{
   int numclosed;

   // Open for read (will fail if file "crt_fopen.c" does not exist)
   if( (stream  = fopen( "crt_fopen.c", "r" )) == NULL ) // C4996
   // Note: fopen is deprecated; consider using fopen_s instead
      printf( "The file 'crt_fopen.c' was not opened\n" );
   else
      printf( "The file 'crt_fopen.c' was opened\n" );

   // Open for write
   if( (stream2 = fopen( "data2", "w+" )) == NULL ) // C4996
      printf( "The file 'data2' was not opened\n" );
   else
      printf( "The file 'data2' was opened\n" );

   // Close stream if it is not NULL
   if( stream)
   {
      if ( fclose( stream ) )
      {
         printf( "The file 'crt_fopen.c' was not closed\n" );
      }
   }

   // All other files are closed:
   numclosed = _fcloseall( );
   printf( "Number of files closed by _fcloseall: %u\n", numclosed );
}

The file 'crt_fopen.c' was opened
The file 'data2' was opened
Number of files closed by _fcloseall: 1

Exempel 2

Följande program skapar en fil (eller skriver över en om den finns) i textläge med Unicode-kodning. Den skriver sedan två strängar i filen och stänger filen. Utdata är en fil med namnet _wfopen_test.xml, som innehåller data från utdataavsnittet.

// crt__wfopen.c
// compile with: /W3
// This program creates a file (or overwrites one if
// it exists), in text mode using Unicode encoding.
// It then writes two strings into the file
// and then closes the file.

#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <wchar.h>

#define BUFFER_SIZE 50

int main(int argc, char** argv)
{
    wchar_t str[BUFFER_SIZE];
    size_t  strSize;
    FILE*   fileHandle;

    // Create an the xml file in text and Unicode encoding mode.
    if ((fileHandle = _wfopen( L"_wfopen_test.xml",L"wt+,ccs=UNICODE")) == NULL) // C4996
    // Note: _wfopen is deprecated; consider using _wfopen_s instead
    {
        wprintf(L"_wfopen failed!\n");
        return(0);
    }

    // Write a string into the file.
    wcscpy_s(str, sizeof(str)/sizeof(wchar_t), L"<xmlTag>\n");
    strSize = wcslen(str);
    if (fwrite(str, sizeof(wchar_t), strSize, fileHandle) != strSize)
    {
        wprintf(L"fwrite failed!\n");
    }

    // Write a string into the file.
    wcscpy_s(str, sizeof(str)/sizeof(wchar_t), L"</xmlTag>");
    strSize = wcslen(str);
    if (fwrite(str, sizeof(wchar_t), strSize, fileHandle) != strSize)
    {
        wprintf(L"fwrite failed!\n");
    }

    // Close the file.
    if (fclose(fileHandle))
    {
        wprintf(L"fclose failed!\n");
    }
    return 0;
}

Se även

Stream I/O-
tolkning av sekvenser med flerabytestecken
fclose, _fcloseall
_fdopen, _wfdopen
ferror
_fileno
freopen, _wfreopen
_open, _wopen
_setmode
_sopen, _wsopen

Dela via

fopen, _wfopen