Qual é a melhor maneira de verificar se existe um arquivo em C?

Existe uma maneira melhor do que simplesmente tentar abrir o arquivo?

int exists(const char *fname)
{
    FILE *file;
    if ((file = fopen(fname, "r")))
    {
        fclose(file);
        return 1;
    }
    return 0;
}

Procure a access()função, encontrada em unistd.h. Você pode substituir sua função por

if( access( fname, F_OK ) != -1 ) {
    // file exists
} else {
    // file doesn't exist
}

Você também pode usar R_OK, W_OKe X_OKno lugar de F_OKverificar a permissão de leitura, a permissão de gravação e executar a permissão (respectivamente) em vez da existência, e você pode OU qualquer um deles juntos (por exemplo, verificar a permissão de leitura e gravação usando R_OK|W_OK)

Atualização : observe que, no Windows, você não pode W_OKtestar com confiabilidade a permissão de gravação, pois a função de acesso não leva em consideração as DACLs. access( fname, W_OK )pode retornar 0 (êxito) porque o arquivo não possui o atributo somente leitura definido, mas você ainda pode não ter permissão para gravar no arquivo.

Use statassim:

#include <sys/stat.h>   // stat
#include <stdbool.h>    // bool type

bool file_exists (char *filename) {
  struct stat   buffer;   
  return (stat (filename, &buffer) == 0);
}

e chame assim:

#include <stdio.h>      // printf

int main(int ac, char **av) {
    if (ac != 2)
        return 1;

    if (file_exists(av[1]))
        printf("%s exists\n", av[1]);
    else
        printf("%s does not exist\n", av[1]);

    return 0;
}

Normalmente, quando você deseja verificar se um arquivo existe, é porque você deseja criar esse arquivo, se não existir. A resposta de Graeme Perrow é boa se você não deseja criar esse arquivo, mas é vulnerável a uma condição de corrida, se o fizer: outro processo pode criar o arquivo entre você, verificando se ele existe e abrindo-o para gravá-lo . (Não ria ... isso pode ter implicações ruins na segurança se o arquivo criado for um link simbólico!)

Se você deseja verificar a existência e criar o arquivo, se não existir, atomicamente , para que não haja condições de corrida, use o seguinte:

#include <fcntl.h>
#include <errno.h>

fd = open(pathname, O_CREAT | O_WRONLY | O_EXCL, S_IRUSR | S_IWUSR);
if (fd < 0) {
  /* failure */
  if (errno == EEXIST) {
    /* the file already existed */
    ...
  }
} else {
  /* now you can use the file */
}

Sim. Use stat(). Veja a página de manual para stat(2).

stat()falhará se o arquivo não existir, caso contrário, provavelmente será bem-sucedido. Se existir, mas você não tiver acesso de leitura ao diretório em que ele existe, também falhará, mas nesse caso qualquer método falhará (como você pode inspecionar o conteúdo de um diretório que talvez não seja exibido de acordo com os direitos de acesso? Simplesmente, você não pode).

Ah, como alguém mencionou, você também pode usar access(). No entanto, prefiro que stat(), como se o arquivo exista, ele imediatamente receba muitas informações úteis (quando foi atualizada pela última vez, qual o tamanho, o proprietário e / ou o grupo que possui o arquivo, as permissões de acesso etc.).

FILE *file;
    if((file = fopen("sample.txt","r"))!=NULL)
        {
            // file exists
            fclose(file);
        }
    else
        {
            //File not found, no memory leak since 'file' == NULL
            //fclose(file) would cause an error
        }

Com a ajuda do Visual C ++, eu costumava usar

/* ACCESS.C: This example uses _access to check the
 * file named "ACCESS.C" to see if it exists and if
 * writing is allowed.
 */

#include  <io.h>
#include  <stdio.h>
#include  <stdlib.h>

void main( void )
{
   /* Check for existence */
   if( (_access( "ACCESS.C", 0 )) != -1 )
   {
      printf( "File ACCESS.C exists\n" );
      /* Check for write permission */
      if( (_access( "ACCESS.C", 2 )) != -1 )
         printf( "File ACCESS.C has write permission\n" );
   }
}

Também vale a pena notar os valores do modo de :_access(const char *path,int mode)

• 00: Apenas existência

• 02: permissão de gravação

• 04: permissão de leitura

• 06: permissão de leitura e gravação

Como você fopenpode falhar em situações em que o arquivo existe, mas não pode ser aberto conforme solicitado.

Edit: Basta ler a publicação de Mecki. stat()parece um caminho mais arrumado. Ho hum.

Você pode usar a função realpath ().

resolved_file = realpath(file_path, NULL);
if (!resolved_keyfile) {
   /*File dosn't exists*/
   perror(keyfile);
   return -1;
}

Eu acho que a função access () , que é encontrada em, unistd.hé uma boa opção para Linux(você também pode usar o stat ).

Você pode usá-lo assim:

#include <stdio.h>
#include <stdlib.h>
#include<unistd.h>

void fileCheck(const char *fileName);

int main (void) {
    char *fileName = "/etc/sudoers";

    fileCheck(fileName);
    return 0;
}

void fileCheck(const char *fileName){

    if(!access(fileName, F_OK )){
        printf("The File %s\t was Found\n",fileName);
    }else{
        printf("The File %s\t not Found\n",fileName);
    }

    if(!access(fileName, R_OK )){
        printf("The File %s\t can be read\n",fileName);
    }else{
        printf("The File %s\t cannot be read\n",fileName);
    }

    if(!access( fileName, W_OK )){
        printf("The File %s\t it can be Edited\n",fileName);
    }else{
        printf("The File %s\t it cannot be Edited\n",fileName);
    }

    if(!access( fileName, X_OK )){
        printf("The File %s\t is an Executable\n",fileName);
    }else{
        printf("The File %s\t is not an Executable\n",fileName);
    }
}

E você obtém a seguinte saída:

The File /etc/sudoers    was Found
The File /etc/sudoers    cannot be read
The File /etc/sudoers    it cannot be Edited
The File /etc/sudoers    is not an Executable