Qual è il modo migliore per verificare se esiste un file in C?

C'è un modo migliore del semplice tentativo di aprire il file?

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

Cerca la access()funzione, trovata in unistd.h. Puoi sostituire la tua funzione con

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

Puoi anche usare R_OK, W_OKe X_OKal posto di F_OKverificare l'autorizzazione alla lettura, l'autorizzazione alla scrittura ed eseguire l'autorizzazione (rispettivamente) anziché l'esistenza, e puoi OPPURE una di esse insieme (cioè verifica l' autorizzazione alla lettura e alla scrittura usando R_OK|W_OK)

Aggiornamento : si noti che su Windows, non è possibile utilizzare W_OKper testare in modo affidabile l'autorizzazione alla scrittura, poiché la funzione di accesso non tiene conto dei DACL. access( fname, W_OK )potrebbe restituire 0 (esito positivo) perché il file non ha l'attributo di sola lettura impostato, ma potresti non disporre dell'autorizzazione per scrivere nel file.

Usa statcosì:

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

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

e chiamalo così:

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

Di solito, quando si desidera verificare l'esistenza di un file, è perché si desidera creare quel file in caso contrario. La risposta di Graeme Perrow è buona se non vuoi creare quel file, ma è vulnerabile a una condizione di competizione se lo fai: un altro processo potrebbe creare il file tra te controllando se esiste e lo stai effettivamente aprendo per scriverlo . (Non ridere ... questo potrebbe avere conseguenze negative sulla sicurezza se il file creato fosse un link simbolico!)

Se vuoi verificare l'esistenza e creare il file se non esiste, atomicamente in modo che non ci siano condizioni di competizione, usa questo:

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

Sì. Usa stat(). Vedi la pagina man per stat(2).

stat()fallirà se il file non esiste, altrimenti molto probabilmente avrà successo. Se esiste, ma non hai accesso in lettura alla directory in cui esiste, fallirà anche, ma in tal caso qualsiasi metodo fallirà (come puoi ispezionare il contenuto di una directory che potresti non vedere in base ai diritti di accesso? Semplicemente, non puoi).

Oh, come ha detto qualcun altro, puoi anche usare access(). Tuttavia preferisco stat(), come se il file esista mi ottenga immediatamente molte informazioni utili (quando è stato aggiornato l'ultima volta, quanto è grande, il proprietario e / o il gruppo che possiede il file, le autorizzazioni di accesso e così via).

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
        }

Con l'aiuto di Visual C ++, tenderei ad andare avanti

/* 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" );
   }
}

Vale anche la pena notare i valori della modalità di :_access(const char *path,int mode)

• 00: Esistenza solo

• 02: permesso di scrittura

• 04: permesso di lettura

• 06: permesso di lettura e scrittura

Poiché fopenpotresti non riuscire nelle situazioni in cui il file esisteva ma non poteva essere aperto come richiesto.

Modifica: basta leggere il post di Mecki. stat()sembra un modo più ordinato di andare. Ho hum.

È possibile utilizzare la funzione realpath ().

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

Penso che la funzione access () , che si trova in, unistd.hsia una buona scelta per Linux(puoi usare anche stat ).

Puoi usarlo in questo modo:

#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 ottieni il seguente output:

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