C fopen vs open

Existe algum motivo (diferente dos sintáticos) que você gostaria de usar

FILE *fdopen(int fd, const char *mode); 

ou

 FILE *fopen(const char *path, const char *mode); 

ao invés de

 int open(const char *pathname, int flags, mode_t mode); 

ao usar C em um ambiente Linux?

   

Primeiro, não há nenhuma razão particularmente boa para usar o fdopen se o fopen é uma opção e o open é a outra escolha possível. Você não deveria ter usado open para abrir o arquivo se você quiser um FILE * . Então include o fdopen nessa lista é incorreto e confuso porque não é muito parecido com os outros. Agora vou continuar a ignorá-lo, porque a distinção importante aqui é entre um FILE * padrão C e um descritor de arquivo específico do sistema operacional.

Existem quatro razões principais para usar fopen em vez de aberto.

  1. fopen fornece buffer de E / S que pode se tornar muito mais rápido do que o que você está fazendo com o open .
  2. fopen faz a tradução final da linha se o arquivo não for aberto no modo binário, o que pode ser muito útil se o seu programa já foi portado para um ambiente não-Unix.
  3. Um FILE * lhe dá a capacidade de usar o fscanf e outras funções do stdio.
  4. Seu código pode um dia precisar ser portado para alguma outra plataforma que suporte apenas ANSI C e não suporta a function open .

Na minha opinião, a linha que termina a tradução entra mais do seu jeito do que o ajuda, e a análise do fscanf é tão fraca que você inevitavelmente acaba jogando em favor de algo mais útil.

E a maioria das plataformas que suportam C tem uma function open .

Isso deixa a questão do buffer. Em locais onde você está principalmente lendo ou escrevendo um arquivo sequencialmente, o suporte a buffering é realmente útil e uma grande melhoria de velocidade. Mas isso pode levar a alguns problemas interessantes nos quais os dados não acabam no arquivo quando você espera que ele esteja lá. Você tem que lembrar de encontrar ou fflush nos momentos apropriados.

Se você está procurando (também conhecido como fsetpos ou fseek o segundo é um pouco mais complicado de usar de uma maneira compatível com os padrões), a utilidade do buffer rapidamente diminui.

Claro, meu viés é que eu costumo trabalhar muito com sockets, e lá o fato de que você realmente quer fazer IOs não bloqueantes (que FILE * não suporta de forma razoável) sem buffering e muitas vezes têm requisitos complexos de análise que realmente colorem minhas percepções.

open() é uma chamada de baixo nível. fdopen() converte um descritor de arquivo do nível do sistema para a abstração FILE de nível superior da linguagem C. fopen() chama open() em segundo plano e lhe dá um ponteiro FILE diretamente.

Há várias vantagens em usar os objects FILE, em vez de descritores de arquivos brutos, que incluem maior facilidade de uso, mas também outras vantagens técnicas, como o buffer interno. Especialmente o buffer geralmente resulta em uma vantagem de desempenho considerável.

fopen vs aberto em C

1) fopen é uma function de biblioteca enquanto open é uma chamada de sistema .

2) fopen fornece IO em buffer, que é mais rápido que o open que não é armazenado em buffer .

3) fopen é portátil enquanto open não portátil ( aberto é específico do ambiente ).

4) fopen retorna um ponteiro para uma estrutura FILE (FILE *) ; open retorna um inteiro que identifica o arquivo.

5) UM FILE * lhe dá a habilidade de usar o fscanf e outras funções do stdio.

Se você tem um FILE * , você pode usar funções como fscanf , fprintf e fgets etc. Se você tiver apenas o descritor de arquivo, você terá rotinas de input e saída limitadas (mas provavelmente mais rápidas), write , etc.

A menos que você faça parte de 0,1% dos aplicativos em que o uso open é um benefício de desempenho real, não há uma boa razão para não usar o fopen . No que diz respeito ao fdopen , se você não estiver jogando com descritores de arquivos, não precisará dessa chamada.

Fique com fopen e sua família de methods ( fwrite , fread , fprintf , et al) e você ficará muito satisfeito. Tão importante quanto isso, outros programadores ficarão satisfeitos com o seu código.

Usando abrir, ler, escrever significa que você precisa se preocupar com as interações de sinal.

Se a chamada foi interrompida por um manipulador de sinal, as funções retornarão -1 e definirão errno como EINTR.

Então a maneira correta de fechar um arquivo seria

 while (retval = close(fd), retval == -1 && ernno == EINTR) ; 

open() é uma chamada de sistema e específica para o sistema baseado em Unix e retorna um descritor de arquivo. Você pode escrever para um filedescriptor usando o write() que é outra chamada de sistema.
fopen() é uma chamada de function ANSI C que retorna um ponteiro de arquivo e é portável para outro sistema operacional. Podemos escrever para o ponteiro de arquivo usando o fprintf .

No Unix:
Você pode obter um ponteiro de arquivo do filedescriptor usando:
fP = fdopen(fD, "a");
Você pode obter um descritor de arquivo do ponteiro de arquivo usando:
fD = fileno (fP);

open () será chamado no final de cada uma das funções da família fopen () . open () é uma chamada de sistema e fopen () são fornecidos por bibliotecas como funções de wrapper para fácil utilização pelo usuário

Depende também de quais sinalizadores são necessários para abrir. Com relação ao uso para escrita e leitura (e portabilidade) f * deve ser usado, como discutido acima.

Mas se basicamente quiser especificar mais que flags padrão (como rw e append flags), você terá que usar uma API específica de plataforma (como abrir POSIX) ou uma biblioteca que abstrai esses detalhes. O padrão C não possui essas bandeiras.

Por exemplo, você pode querer abrir um arquivo apenas se ele sair. Se você não especificar o sinalizador de criação, o arquivo deverá existir. Se você adicionar exclusivo para criar, ele só criará o arquivo se ele não existir. Existem muitos mais.

Por exemplo, em sistemas Linux, existe uma interface de LEDs exposta através do sysfs. Ele expõe o brilho do led através de um arquivo. Escrever ou ler um número como uma string variando de 0 a 255. Claro que você não quer criar esse arquivo e só escrever para ele se ele existir. O legal agora: use o fdopen para ler / gravar esse arquivo usando as chamadas padrão.

Eu mudei para open () de fopen () para o meu aplicativo, porque fopen estava causando leituras duplas toda vez que eu rodava fgeten fgeten. Leituras duplas foram perturbadoras do que eu estava tentando realizar. open () apenas parece fazer o que você pede.

abrindo um arquivo usando fopen
antes que possamos ler (ou gravar) informações de (para) um arquivo em um disco, devemos abrir o arquivo. para abrir o arquivo, chamamos a function fopen.

 1.firstly it searches on the disk the file to be opened. 2.then it loads the file from the disk into a place in memory called buffer. 3.it sets up a character pointer that points to the first character of the buffer. 

este o caminho do comportamento da function fopen
Existem algumas causas durante o processo de buffer, pode ser esgotado. Então, ao comparar fopen (i / o de alto nível) para abrir (baixo nível i / o) chamada do sistema, e é um mais rápido mais adequado do que fopen .