¿Cuál es la mejor manera de verificar si existe un archivo en C?

Question 1

¿Hay una mejor manera que simplemente intentar abrir el archivo?

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

Question 2

busca el access() función, que se encuentra en unistd.h. Puede reemplazar su función con

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

Bajo Windows (VC) unistd.h no existe. Para que funcione es necesario definir:

#ifdef WIN32
#include <io.h>
#define F_OK 0
#define access _access
#endif

También puedes usar R_OK, W_OKy X_OK en lugar de F_OK para verificar el permiso de lectura, el permiso de escritura y el permiso de ejecución (respectivamente) en lugar de la existencia, y puede O cualquiera de ellos juntos (es decir, verificar ambos lectura y permiso de escritura usando R_OK|W_OK)

Actualizar: Tenga en cuenta que en Windows, no puede usar W_OK para probar de forma fiable el permiso de escritura, ya que la función de acceso no tiene en cuenta las DACL. access( fname, W_OK ) puede devolver 0 (éxito) porque el archivo no tiene establecido el atributo de solo lectura, pero es posible que aún no tenga permiso para escribir en el archivo.

Question 3

Usar stat Me gusta esto:

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

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

y llámalo así:

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

Question 4

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
        }

Question 5

pienso que acceso() función que se encuentra en unistd.h es una buena opción para Linux (puedes usar estadística también).

Puedes usarlo así:

#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);
    }
}

Y obtienes la siguiente salida:

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

Question 6

Sí. Usar stat(). Vea la página del manual parastat(2).

stat() fallará si el archivo no existe; de lo contrario, lo más probable es que tenga éxito. Si existe, pero no tiene acceso de lectura al directorio donde existe, también fallará, pero en ese caso fallará cualquier método (¿cómo puede inspeccionar el contenido de un directorio que no puede ver de acuerdo con los derechos de acceso? Simplemente, no puedes).

Oh, como alguien más mencionó, también puedes usar access(). Sin embargo, prefiero stat()como si el archivo existiera, inmediatamente obtendría mucha información útil (cuándo se actualizó por última vez, qué tan grande es, propietario y/o grupo propietario del archivo, permisos de acceso, etc.).

Question 7

Por lo general, cuando desea verificar si existe un archivo, es porque desea crear ese archivo si no es así. La respuesta de Graeme Perrow es buena si no desea crear ese archivo, pero es vulnerable a una condición de carrera si lo hace: otro proceso podría crear el archivo entre usted, verificando si existe, y realmente abriéndolo para escribir en él. (No te rías… esto podría haber malo implicaciones de seguridad si el archivo creado fuera un enlace simbólico!)

Si desea comprobar la existencia y crear el archivo si no existe, atómicamente para que no haya condiciones de carrera, entonces usa esto:

#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 */
}

Question 8

Puede usar la función realpath().

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

¿Ha sido útil esta solución?