FAQ CConsultez toutes les FAQ

Nombre d'auteurs : 27, nombre de questions : 175, dernière mise à jour : 17 décembre 2010  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 :
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 echoue => le fichier "fichier.txt" n'existe pas. */ 
} 
else 
{ 
    /* Le fichier a pu etre 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 :
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 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 :
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 :
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 :
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 commencant 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 :
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 :
1
2
3
#include <stdio.h> 
  
int remove(const char * pathname);

Mis à jour le 12 avril 2003 LFE

Sous Windows, on utilise les fonction 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 :
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 :
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 :
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 ce 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

libzip

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 © 2014 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.

 
 
 
 
Partenaires

PlanetHoster
Ikoula