Quelle est la meilleure façon de vérifier si un fichier existe en C?

Existe-t-il un meilleur moyen que d'essayer simplement d'ouvrir le fichier?

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

Recherchez la access()fonction, trouvée dans unistd.h. Vous pouvez remplacer votre fonction par

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

Vous pouvez également utiliser R_OK, W_OKet X_OKà la place de F_OKpour vérifier l'autorisation de lecture, l'autorisation d'écriture et exécuter l'autorisation (respectivement) plutôt que l'existence, et vous pouvez OU l'un ou l'autre ensemble (c.-à-d. Vérifier les autorisations de lecture et d' écriture à l'aide R_OK|W_OK)

Mise à jour : Notez que sous Windows, vous ne pouvez pas utiliser W_OKpour tester de manière fiable l'autorisation d'écriture, car la fonction d'accès ne prend pas en compte les DACL. access( fname, W_OK )peut renvoyer 0 (succès) car le fichier n'a pas l'attribut en lecture seule défini, mais vous ne pouvez toujours pas avoir l'autorisation d'écrire dans le fichier.

Utilisez statcomme ceci:

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

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

et appelez-le comme ceci:

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

Habituellement, lorsque vous souhaitez vérifier si un fichier existe, c'est parce que vous souhaitez créer ce fichier s'il ne l'est pas. La réponse de Graeme Perrow est bonne si vous ne voulez pas créer ce fichier, mais elle est vulnérable à une condition de concurrence si vous le faites: un autre processus pourrait créer le fichier entre vous en vérifiant s'il existe, et vous l'ouvrez réellement pour y écrire . (Ne riez pas ... cela pourrait avoir de mauvaises implications sur la sécurité si le fichier créé était un lien symbolique!)

Si vous souhaitez vérifier l'existence et créer le fichier s'il n'existe pas, de manière atomique afin qu'il n'y ait pas de conditions de concurrence, alors utilisez ceci:

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

Oui. Utilisez stat(). Voir la page de manuel pour stat(2).

stat()échouera si le fichier n'existe pas, sinon il est fort probable qu'il réussisse. S'il existe, mais que vous n'avez pas d'accès en lecture au répertoire où il se trouve, il échouera également, mais dans ce cas, n'importe quelle méthode échouera (comment pouvez-vous inspecter le contenu d'un répertoire que vous ne voyez pas selon les droits d'accès? Tout simplement, vous ne pouvez pas).

Oh, comme quelqu'un l'a mentionné, vous pouvez également l'utiliser access(). Cependant, je préfère stat(), car si le fichier existe, il me fournira immédiatement beaucoup d'informations utiles (quand a-t-il été mis à jour pour la dernière fois, quelle est sa taille, propriétaire et / ou groupe propriétaire du fichier, autorisations d'accès, 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
        }

De l'aide de Visual C ++, j'aurais tendance à aller avec

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

Il convient également de noter les valeurs de mode de :_access(const char *path,int mode)

• 00: Existence uniquement

• 02: autorisation d'écriture

• 04: autorisation de lecture

• 06: autorisation de lecture et d'écriture

Comme votre fopen pourrait échouer dans des situations où le fichier existait mais n'a pas pu être ouvert comme demandé.

Edit: Il suffit de lire le post de Mecki. stat()ressemble à une façon plus nette d'aller. Ho hum.

Vous pouvez utiliser la fonction realpath ().

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

Je pense que la fonction access () , qui se trouve dans, unistd.hest un bon choix pour Linux(vous pouvez aussi utiliser stat ).

Vous pouvez l'utiliser comme ceci:

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

Et vous obtenez la sortie suivante:

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