fopen, _wfopen

em aberto um arquivo.Versões mais seguras dessas funções estão disponível; consulte fopen_s, _wfopen_s.

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

Parâmetros

• filename
  Nome de arquivo.

• mode
  Tipo de acesso permitido.

Valor de retorno

Cada uma dessas funções retorna um ponteiro para o arquivo em aberto.Um valor de ponteiro nulo indica um erro.If filename ou mode é NULL ou uma seqüência vazia, essas funções acionam o manipulador de parâmetro inválido, conforme descrito em Validação de parâmetro. Se a execução for permitida para continuar, essas funções retornam NULL e conjunto errno para EINVAL.

See _doserrno, errno, _sys_errlist e _sys_nerr para obter mais informações sobre esses e outros, códigos de erro.

Comentários

Versões mais seguras dessas funções existir, consulte fopen_s, _wfopen_s.

The fopen função abre o arquivo especificado por filename. _wfopené uma versão de caractere largo da fopen; os argumentos para _wfopensão seqüências de caracteres largos. _wfopen e fopen tenham comportamento idêntico caso contrário. Simplesmente usando _wfopen não tem efeito sobre o codificado conjunto de caracteres usada no fluxo do arquivo.

fopen aceitará caminhos válido no sistema de arquivos no ponto de execução; caminhos UNC e caminhos de unidades de rede mapeadas envolvendo são aceitos pelo fopen sistema autônomo longo sistema autônomo o sistema executando o código h sistema autônomo acesso ao compartilhamento ou unidade de rede mapeada no momento da execução. Especial deve ter cuidado ao construir caminhos de fopen Para evitar fazer suposições sobre unidades disponível, caminhos ou rede compartilha no ambiente de execução.

Sempre verifique o valor retornado para ver se o ponteiro é nulo antes de executar quaisquer operações adicionais no arquivo.If an error occurs, the global variableerrno is set and may be used to get specific error information.Para obter mais informações, consulte errno.

In Visual C++ 2005, fopen oferece suporte a fluxos de arquivo Unicode. Um sinalizar especificando a codificação desejada pode ser passado para fopen Quando abrir um novo arquivo ou substituir um arquivo existente, assim:

fopen("newfile.txt", "rw, ccs=<encoding>");

Valores permitidos do encoding incluir UNICODE, UTF-8, e UTF16-LE. Se o arquivo já está em existência e é aberto para leitura ou acrescentando, Mark ordem de byte (BOM) é usado para determinar a codificação correta.Não é necessário especificar a codificação com um sinalizar.Na verdade, o sinalizar será ignorado se ela está em conflito com o tipo de arquivo sistema autônomo indicado pelo BOM.O sinalizar é usado somente quando nenhum BOM está presente ou se o arquivo é um novo arquivo.A tabela a seguir resume os modos usados para vários sinalizadores para fopen e marcas de ordem byte usado no arquivo.

Codificações usado com base no sinalizar e BOM

Sinalizador	Nenhuma BOM (ou o novo arquivo)	BOM: UTF-8	BOM: UTF-16
UNICODE	ANSI	UTF-8	UTF-16LE
UTF-8	UTF-8	UTF-8	UTF-16LE
UTF-16LE	UTF-16LE	UTF-8	UTF-16LE

If modeé"a, ccs=<encoding>", fopen primeiro tentará em em aberto o arquivo com o acesso de leitura e gravar. Se tiver êxito, será exibido o BOM para determinar a codificação deste arquivo; no entanto, se ele falhar, ele usará a codificação padrão para o arquivo.Em ambos os casos, fopen será, em seguida, reabra o arquivo com acesso somente gravar. (Isso se aplica ao modo de a não somente, a+.)

Mapeamentos de rotina de texto genérica

Rotina TCHAR.H	_UNICODE & _MBCS não definido	_MBCS definido	_UNICODE definido
_tfopen	fopen	fopen	_wfopen

O caractere de seqüência de caracteres mode Especifica o tipo de acesso solicitado para o arquivo, da seguinte maneira:

• "r"
  Será aberto para leitura.Se o arquivo não existe ou não for encontrado, o fopen Chame falhar.

• "w"
  Abre um arquivo vazio para gravação.Se existir o arquivo fornecido, seu Sumário será destruído.

• "a"
  É aberto para gravação no participante do arquivo (acrescentar) sem remover o marcador EOF antes de gravar novos dados para o arquivo; cria o arquivo primeiro se ele não existir.

• "r+"
  Será aberto para leitura e gravação.(O arquivo deve existir).

• "w+"
  Abre um arquivo vazio para ler e gravar.Se existir o arquivo fornecido, seu Sumário será destruído.

• "a+"
  Será aberto para leitura e acrescentando; acrescentando operação inclui a remoção do marcador EOF antes que novos dados são gravados no arquivo e o marcador EOF é restaurado após a gravação seja concluído; cria o arquivo primeiro se ele não existir.

Quando um arquivo for aberto com o "a" ou "a+" tipo de acesso gravar todas as operações ocorrem ao participante do arquivo. O ponteiro do arquivo pode ser reposicionado fseek ou rewind, mas é sempre retornado ao participante do arquivo antes de escrever nenhuma operação é executada. Assim, os dados existentes não podem ser substituídos.

The "a" não remove o marcador EOF antes acrescentando o arquivo. Após a ocorrência de acréscimo, o comando MS-DOS TYPE mostra somente dados até o marcador EOF original e não os dados anexados ao arquivo.The "a+" modo irá remover o marcador EOF antes de acrescentá-lo. Após importar, o comando MS-DOS TYPE, mostra todos os dados no arquivo.The "a+" o modo é necessário para acrescentar a um arquivo de fluxo que é encerrado com o marcador EOF CTRL+Z.

Quando o "r+", "w+", or "a+"tipo de acesso for especificado, tanto leitura e gravação são permitidos (o arquivo é considerado em aberto para "atualização"). No entanto, quando você alterna entre a leitura e gravação, deve haver um intermediárias fflush, fsetpos, fseek, ou rewind operação. A posição corrente pode ser especificada para o fsetpos ou fseek operação, se desejado.

Juntamente com os valores acima, os caracteres a seguir podem ser incluídos em mode Para especificar o modo de tradução de caracteres de nova linha:

• t
  em em aberto em texto (convertida) modo.Nesse modo, CTRL+Z é interpretado sistema autônomo um caractere de participante de arquivo na entrada.Em arquivos abertos para leitura/gravação com "a+", fopen verifica um CTRL+Z no participante do arquivo e remove-lo, se possível. Isso é concluído porque usando fseek e ftell Para mover dentro de um arquivo que termina com um CTRL+Z, podem causar fseek se comporte incorretamente no participante do arquivo.

Além disso, no modo de texto, carro return–linefeed combinações são traduzidas para alimentações de linha única na entrada e caracteres de avanço de linha são convertidos em combinações de return–linefeed carro na saída.Quando uma função de fluxo de E/S Unicode opera no modo de texto (padrão), fonte ou fluxo de destino será considerado uma sequência de caracteres multibyte.Portanto, sistema autônomo funções de fluxo de entrada Unicode converter multibyte caracteres para caracteres largos (sistema autônomo se por uma telefonar para o mbtowc função). Pelo mesmo motivo, sistema autônomo funções de fluxo de saída Unicode convertem caracteres largos caracteres multibyte (sistema autônomo se por uma telefonar para o wctomb função).

• b
  em em aberto no modo binário (não traduzido); traduções envolvendo caracteres de retorno de carro e avanço de linha são suprimidas.

If t ou b não é fornecido na mode, o modo de tradução padrão é definido pela variável global _fmode.If t ou b tem o prefixo para o argumento, a função falha e retorna NULL.

Para obter mais informações sobre como usar o texto e modos de binários em Unicode e multibyte fluxo de I/O, consulte Texto e o modo binário arquivo I/O and Unicode Stream I/O no texto e modos binários.

• c
  Ativar o sinalizar de confirmar para o associado filename para que o Sumário do buffer de arquivo é gravado diretamente no disco se qualquer uma fflush ou _flushall é chamado.

• n
  reiniciar o sinalizar de confirmar para o associado filenamepara "não-confirmar". Este é o padrão.Ela também substitui o sinalizar de confirmar global se você vincular o seu programa com COMMODE.OBJ.O padrão de sinalizar de confirmar global é "não-confirmar", a menos que você explicitamente vincular seu programa com COMMODE.OBJ (consulteOpções de link).

• N
  Especifica que o arquivo não é herdado pelos processos filhos.

• S
  Especifica que o cache é otimizado para, mas não restrito a, acesso seqüencial do disco.

• R
  Especifica que o cache é otimizado para, mas não restrito a, acesso aleatório do disco.

• T
  Especifica um arquivo sistema autônomo temporário.Se possível, ele não é liberado para o disco.

• D
  Especifica um arquivo sistema autônomo temporário.Ele é excluído quando o último ponteiro de arquivo é fechado.

• ccs=ENCODING
  Especifica o conjunto de caractere codificados para usar (UTF-8, UTF-16LE, ou UNICODE) para este arquivo. Deixe não especificado se desejar que a codificação ANSI.Essa opção está disponível em Visual C++ 2005 e mais recente.

Caracteres válido para o mode seqüência de caracteres usada na fopen e _fdopen corresponde a oflag argumentos usados na _Open and _sopen, sistema autônomo segue.

Caracteres na cadeia de modo	Equivalente oflag valor para _open/_sopen
a	_O_WRONLY | _O_APPEND (normalmente _O_WRONLY | _O_CREAT | _O_APPEND)
a+	_O_RDWR | _O_APPEND (normalmente _O_RDWR | _O_APPEND | _O_CREAT )
r	_O_RDONLY
r+	_O_RDWR
w	_O_WRONLY (normalmente _O_WRONLY | _O_CREAT | _O_TRUNC)
w+	_O_RDWR (normalmente _O_RDWR | _O_CREAT | _O_TRUNC)
b	_O_BINARY
t	_O_TEXT
c	Nenhum
n	Nenhum
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

Se você estiver usando rb modo, não precisará portar seu código e pretende ler muita o arquivo e/ou não se preocupa com o desempenho da rede, arquivos Win32 de memória mapeada podem ser também uma opção.

Requisitos

Função	Cabeçalho necessário
fopen	<stdio.h>
_wfopen	<stdio.h> ou <wchar.h>

Para obter informações adicionais compatibilidade, consulte Compatibilidade na introdução.

The c, n, t,S,R,T andD mode options are Microsoft extensions for fopen and _fdopen and should not be used where ANSI portability is desired.

Exemplo

Este programa abre os dois arquivos.It usesfclose to close the first file and _fcloseall to close all remaining files.

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

Este programa cria um arquivo (ou substitui um se ele existir), no modo de texto usando a codificação Unicode.Ele grava duas cadeias de caracteres no arquivo e, em seguida, fecha o arquivo.A saída é um arquivo chamado _wfopen_test.xml, que deve conter os dados da seção de saída.

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

Equivalente do NET Framework

• sistema::IO::arquivo::em aberto

• sistema::IO::FileStream::FileStream

Consulte também

Referência

Fluxo de E/S

Interpretação de seqüências de caractere multibyte

fclose, _fcloseall

_fdopen, _wfdopen

ferror

_fileno

freopen, _wfreopen

_Open, _wopen

_setmode

_sopen, _wsopen