IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
logo

FAQ CConsultez toutes les FAQ

Nombre d'auteurs : 35, nombre de questions : 194, dernière mise à jour : 18 février 2018  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums de www.developpez.com et de l'expérience personnelle des auteurs.

Je tiens à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose sont correctes ; les auteurs font le maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous trouvez une erreur, ou que vous souhaitez devenir rédacteur, lisez ceci .

Sur ce, je vous souhaite une bonne lecture.

SommaireLes entrées/sortiesLes fichiers et les dossiers (7)
précédent sommaire suivant
 

La solution la plus simple pour vérifier si un fichier existe c'est d'essayer de l'ouvrir.

Code C : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
FILE * fp = fopen("fichier.txt", "rb"); 
  
if (fp == NULL) 
{ 
    /* L'ouverture du fichier "fichier.txt" a échoué => le fichier "fichier.txt" n'existe pas. */ 
} 
else 
{ 
    /* Le fichier a pu être ouvert => le fichier existe. */ 
    fclose(fp); 
}
Cependant, cette technique n'est pas à 100 % sûre, car si le fichier a pu être ouvert, c'est en effet qu'il existe. Mais s'il n'a pas pu être ouvert, ça ne signifie pas forcément que le fichier n'existe pas (plusieurs raisons peuvent amener la demande d'ouverture d'un fichier à l'échec : le fichier n'existe pas, le système ne dispose pas d'assez de mémoire pour effectuer l'opération, vous n'avez pas le droit d'ouvrir le fichier, etc.). Il n'existe malheureusement pas de méthode standard qui permette de connaître la cause de l'échec de l'ouverture du fichier. Sous DOS/Windows et les systèmes de type UNIX, on peut tester si errno est égal à ENOENT (No entry (no such file or directory)).

Mis à jour le 31 janvier 2003 Laurent Gomila LFE

Cette petite fonction permet de calculer très simplement la taille d'un fichier.

Code C : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h> 
  
int fsize(const char * fname, long * ptr) 
{ 
    /* Cette fonction retourne 0 en cas de succès, une valeur différente dans le cas contraire. */ 
    /* La taille du fichier, si elle a pu être calculée, est retournée dans *ptr                */ 
  
    FILE * f; 
    int ret = 0; 
  
    f = fopen(fname, "rb");    
    if (f != NULL) 
    { 
        fseek(f, 0, SEEK_END); /* aller à la fin du fichier */ 
        *ptr = ftell(f); /* lire l'offset de la position courante par rapport au début du fichier */ 
        fclose(f); 
    } 
    else 
        ret = 1; 
  
    return ret; 
}
Le problème c'est que sous Windows par exemple, la taille d'un fichier peut dépasser la plus grande valeur positive représentable par le type long. La fonction GetFileAttributesEx permet de connaître entre autres la taille d'un fichier sans limitation comme dans le cas précédent. Rappelons que sur Win32, la taille du type unsigned int est de 4 octets (32 bits) ce qui signifie que la valeur maximale représentable par ce type est 2 ^ 32 - 1. GetFileAttributesEx retourne la taille du fichier sur une valeur de 64 bits ce qui est assez grand pour représenter la taille de n'importe quel fichier manipulable sous Windows. En fait, il s'agit de deux valeurs de 32 bits : la partie haute, qui vaut 0 si la taille du fichier est inférieure à 2 ^ 32 octets soit 4 Go et la partie basse, les premiers 32 bits.

Code C : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <windows.h> 
  
int FileSize(const char * FileName, unsigned int * ptr) 
{ 
    /* Cette fonction retourne 0 en cas de succès, une valeur différente dans le cas contraire. */ 
    /* La taille du fichier, si elle a pu être calculée, est retournée dans *ptr                */ 
  
    WIN32_FILE_ATTRIBUTE_DATA attr; 
    int ret = 0; 
  
    if (GetFileAttributesEx(FileName, GetFileExInfoStandard, &attr)) 
    { 
        /* La taille du fichier (entre autres) a pu être lue */ 
  
        if (attr.nFileSizeHigh == 0) 
        { 
            /* Le fichier fait moins de 4 Go */ 
  
            *ptr = attr.nFileSizeLow; 
        } 
        else 
            ret = 2; 
    } 
    else 
        ret = 1; 
  
    return ret; 
}

Mis à jour le 2 février 2003 Aurelien.Regat-Barrel gl LFE

Il n'existe pas en C de fonction réalisant la copie d'un fichier. Il est donc nécessaire de créer une fonction lisant le fichier pour le copier dans le fichier de destination.

Code C : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <stdio.h> 
  
int copier_fichier(char const * const source, char const * const destination) 
{ 
    FILE* fSrc; 
    FILE* fDest; 
    char buffer[512]; 
    int NbLus; 
  
    if ((fSrc = fopen(source, "rb")) == NULL) 
    { 
        return 1; 
    } 
  
    if ((fDest = fopen(destination, "wb")) == NULL) 
    { 
        fclose(fSrc); 
        return 2; 
    } 
  
    while ((NbLus = fread(buffer, 1, 512, fSrc)) != 0) 
        fwrite(buffer, 1, NbLus, fDest); 
  
    fclose(fDest); 
    fclose(fSrc); 
  
    return 0; 
}
Remarque : il est aisé de modifier cette fonction afin de concaténer le fichier source avec le fichier destination en ouvrant ce fichier en mode ajout ("ab").

Sous Windows, il y a la fonction CopyFile qui permet de ne pas avoir à coder sa propre fonction.

Code C : Sélectionner tout
1
2
3
4
BOOL CopyFile( LPCTSTR lpExistingFileName,  /* Nom du fichier source */ 
               LPCTSTR lpNewFileName,       /* Nom du fichier destination */ 
               BOOL bFailIfExists           /* Si != 0, la copie sera annulée si le fichier existe déjà */ 
);

Mis à jour le 20 septembre 2004 gl

Le langage C ne fournit pas de fonction pour supprimer une ligne dans un fichier, il faut obligatoirement lire le fichier et de recopier chaque ligne hormis celles que nous désirons supprimer. Voici un exemple de programme supprimant les lignes commençant par # dans un fichier (afin de ne pas surcharger inutilement le code de l'exemple, nous supposons qu'aucune ligne ne fait plus de 256 caractères).

Code C : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <stdio.h> 
#include <stdlib.h> 
  
int main(void) 
{ 
    char ligne[256]; 
    FILE * fIn; 
    FILE * fOut; 
  
    if ((fIn = fopen("texte.txt", "r")) == NULL) 
        return EXIT_FAILURE; 
  
    if ((fOut = fopen("texte.tmp", "w")) == NULL) 
    { 
        fclose(fIn); 
        return EXIT_FAILURE; 
    } 
  
    while (fgets(ligne, sizeof ligne, fIn)) 
    { 
        if (ligne[0] != '#') 
            fputs(ligne, fOut); 
    } 
  
    fclose(fIn); 
    fclose(fOut); 
  
    rename("texte.tmp", "texte.txt"); 
  
    return 0; 
}

Le principe est le même pour supprimer un enregistrement d'un fichier binaire.

Mis à jour le 20 septembre 2004 gl

Sous Windows, à l'aide de DeleteFile (inclure windows.h) et sous UNIX (et plus généralement n'importe quel système se conformant à la norme POSIX), à l'aide de la fonction unlink (déclarée dans unistd.h). La bibliothèque standard du C fournit également une fonction qui sait remplir cette tâche qui n'est autre que remove (déclarée dans stdio.h).

Code C : Sélectionner tout
1
2
3
#include <stdio.h> 
  
int remove(const char * pathname);

Mis à jour le 12 avril 2003 LFE

Sous Windows, on utilise les fonctions FindFirstFile() et FindNextFile() en recherchant les fichiers nommés "*.*" (c'est-à-dire tous les fichiers, tous les dossiers). Le HANDLE retourné par FindFirstFile() doit être fermé dès qu'il n'est plus nécessaire grâce à la fonction FindClose(). Ces fonctions ne parcourent pas les sous-dossiers. Le programme suivant liste le contenu du répertoire courant.

Code C : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h> 
#include <windows.h> 
  
int main(void) 
{ 
    WIN32_FIND_DATA File; 
    HANDLE hSearch; 
  
    hSearch = FindFirstFile("*.*", &File); 
    if (hSearch != INVALID_HANDLE_VALUE) 
    { 
        do { 
            printf("%s\n", File.cFileName); 
        } while (FindNextFile(hSearch, &File)); 
  
        FindClose(hSearch); 
    } 
  
    return 0; 
}
Dans un environnement conforme à la norme POSIX, on utilisera plutôt opendir(), readdir() puis closedir().

Code C : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h> 
#include <dirent.h> 
  
int main(void) 
{ 
    DIR * rep = opendir("."); 
  
    if (rep != NULL) 
    { 
        struct dirent * ent; 
  
        while ((ent = readdir(rep)) != NULL) 
        { 
            printf("%s\n", ent->d_name); 
        } 
  
        closedir(rep); 
    } 
  
    return 0; 
}

Mis à jour le 2 mars 2003 Bob

libzip permet de lire, de créer et de modifier les archives zip. L'extrait de code suivant ajoute un fichier dans une archive, l'archive sera créée si elle n'existe pas encore.

Code C : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int visu; 
struct zip * f_zip=NULL; 
struct zip_source * n_zip=NULL; 
  
f_zip=zip_open("feuille.zip",ZIP_CREATE,NULL); 
n_zip=zip_source_file(f_zip,"content.xml",0,0); /* le nom de ce document est sans importance */ 
if ((visu=zip_name_locate(f_zip,"content.xml",ZIP_FL_NOCASE)==-1) /* recherche de l'emplacement du fichier content.xml dans le zip */ 
{   /* nouveau document dans le fichier zip  : le fichier content.xml n'y est pas */ 
    zip_add(f_zip,"content.xml",n_zip); /* c'est là qu'on fixe le nom qu'aura le nouveau document dans le fichier zip */ 
} 
else 
{   /* modification d'un document dans le fichier zip : content.xml est déjà dedans */ 
    zip_replace(f_zip,visu,n_zip); /* notre document remplace le document qui se trouve à l'emplacement visu */ 
}                                  /* et récupère le nom de l'ancien document */ 
zip_close(f_zip);

Mis à jour le 17 décembre 2010 troumad

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2024 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.