Plusieurs façon de manipuler les fichiers (fonctionnalités système, fonction héritées du C), mais le plus simple est d'utiliser les flux (stream). Vous connaissez déjà les flux (stream) avec std::cout et std::cin. Pour rappel, vous pouvez envoyer des données vers un flux en utilisant l'opérateur « et lire des données en utilisant l'opérateur ».

Les fichiers peuvent donc être manipulés comme des flux, en utilisant fstream (“file stream”) pour lecture et/ou écriture ou classes plus spécialisées ofstream (output file stream) et ifstream (input file stream) respectivement pour l'écriture dans un fichier et la lecture. Ces classes sont disponibles dans le fichier d'en-tête <fstream>.

Pour créer une flux sur un fichier, créer simplement une objet de type stream en passant en argument le nom du fichier. Par exemple, pour écrire dans un fichier qui s'appelle “test.txt” :

main.cpp

#include <iostream>
#include <fstream>
 
int main() {
    std::ofstream file("test.txt");
    return 0;
}

Si vous créer un fichier en écriture et que celui-ci n'existe pas, alors le fichier sera créer. Dans Coliru.com, vous pouvez par exemple modifier la ligne de commande utilisée pour compiler et appeler le programme pour ajouter la fonction “ls” pour afficher la liste des fichiers.

clang++ -std=c++14 -Wall -Wextra -pedantic main.cpp && ./a.out && ls

Si vous commentez la ligne de code contenant la variable file (en ajoutant / / au début de la ligne), la fonction ls affiche :

a.out
main.cpp

Le fichier “a.out” est votre programme, qui est généré lors de la compilation. (Ce nom est celui donné par défaut par le compilateur. Il est bien sûr possible de le changer, mais cela n'est pas important pour le moment, vous verrez plus tard l’utilisation plus avancée des compilateurs).

Le fichier “main.cpp” est le fichier texte contenant votre code C++. (C'est le fichier créé automatiquement par Coliru.com, pour sauvegarder le code C++ que vous tapez dans l'éditeur en ligne).

Avec std::ofstream, la fonction ls affiche :

a.out
main.cpp
test.txt

Vous voyez maintenant un troisième fichier qui s'appelle “test.txt”.

En fait, avec une seule ligne de code, le programme fait plusieurs choses. Lors de la création de la variable de type std::ofstream :

• création du fichier “test.txt” ;
• ouverture de ce fichier ;
• création d'un flux pour écrire sur ce fichier.

Mais ce n'est pas tout. La variable file est une variable locale et suis donc les règles que vous avez vu concernant la portée et la durée de vie des variables locales : elles existent à partir du moment où elles sont déclarées et sont détruites à la fin du bloc de code dans lequel elles sont déclarées.

Pour la variable std::ofstream, cela veut dire qu'elle est détruite à la fin de la fonction main.

int main() {
    std::ofstream file("test.txt");  // création de la variable "file"
    return 0;
}                                    // destruction de la variable "file"

En général, la destruction d'une variable (ou plus être plus exacte, “la fin de portée d'une variable”) permet simplement de libérer la mémoire utilisée par cette variable, pour qu'elle puisse être réutilisée pour d'autres variables.

Mais en fait, la destruction d'une variable peut faire beaucoup plus de choses que de simplement libérer la mémoire. Cela peut faire tout ce qui est nécessaire pour libérer correctement les ressources. Par exemple, pour un fichier, cela va permettre :

• d'écrire les données dans le fichier (souvenez-vous que les flux utilisent des tampons mémoires et sont écrit en asynchrone) ;
• d'enregistrer le fichier ;
• et de le fermer.

Il est possible d'ouvrir et fermer un fichier à n'importe quel moment, sans devoir créer et détruite une nouvelle variable fstream à chaque fois, en utilisant les fonctions open (ouvrir) et close (fermer). Par exemple, cela permet d'ouvrir un fichier en lecture, écrire dedans, le fermer ou le ré-ouvrir en écriture, tout cela avec une seule variable.

Dans ce cours, une importance particulière est mise sur la gestion des ressources via l'utilisation des variables locales. L'utilisation des fonctions open et close n'est pas détaillée. Pour écrire puis lire un même fichier, il est donc recommandé dans ce cours de créer deux variables locales, en utilisant des blocs de code pour gérer les ouvertures et fermetures de fichier.

main.cpp

#include <iostream>
#include <fstream>
 
int main() {
    {
        std::ofstream file("test.txt");  // ouverture du fichier en écriture
        file << ...                      // écriture des données
    }                                    // fermeture du fichier
    {
        std::ifstream file("test.txt");  // ouverture du fichier en lecture
        file >> ...                      // lecture des données
    }                                    // fermeture du fichier
    return 0;
}

Une fois que le fichier est ouvert en écriture avec std::ofstream, vous pouvez écrire directement dedans en utilisant l'opérateur «.

main.cpp

#include <iostream>
#include <fstream>
 
int main() {
    std::ofstream file("test.txt");
    file << "Hello word! " << std::endl;
    file << 1234 << std::endl;
    return 0;
}

Pour voir le contenu du fichier sur Coliru.com, vous pouvez utiliser la commande “cat nom_fu_fichier” à la place de “ls”.

clang++ -std=c++14 -Wall -Wextra -pedantic main.cpp && ./a.out && cat test.txt

affiche :

Hello word! 
1234

Pour rappel, std::endl force également l'écriture des données dans le tampon mémoire (flush). Pour éviter cela, il est possible d'utiliser le caractère “retour à la ligne” \n. Dans ce cours, les performances ne sont pas critiques, l'utilisation de std::endl sera privilégiée.

Pour lire les données, vous pouvez créer un flux de type std::ifstream et utiliser l'opérateur ».

main.cpp

#include <iostream>
#include <fstream>
 
int main() {
    std::ifstream file("test.txt");
    std::string s {};
    file >> s;
    return 0;
}

Le premier paramètre est le nom du fichier. Attention, le chemin par défaut est celui de l'application, pas celui du fichier .cpp (s'ils ne sont pas au même endroit). Possibilité de mettre chemin relatif ou absolu :

std::ofstream file("out.txt");
std::ofstream file("../../out.txt");
std::ofstream file("C:/myapp/out.txt");

Remarque : normalement, sous Windows, le séparateur de chemin est la barre oblique inversée \. Vous pouvez l'utiliser, mais n'oublier pas que ce caractère correspond au caractère d'échappement en C++, il faut dont écrire \\ ou utiliser une chaîne brute :

std::ofstream file("C:\\myapp\\out.txt");  // double barre oblique inversée
std::ofstream file(R"(C:\myapp\out.txt)"); // chaîne brute

Le second paramètre permet de spécifier les options d'ouverture :

• std::ios::binary : ouverture en mode binaire ;

• std::ios::in : en lecture (pour fstream) ;
• std::ios::out : en écriture (pour fstream) ;

• std::ios::app (append = “ajouter”) : ajoute à la fin du fichier ;
• std::ios::trunc (truncate = “tronquer”) : supprimer le contenu ;
• std::ios::ate (at the end = “à la fin”) : ajoute à la fin lors de l'ouverture.

std::fstream f { ... };
assert(f.is_open());
assert(f.is_readable());
f << "hello world";

std::ofstream f { ... };
assert(f.is_open());
f << "hello world";

std::fstream f { ... };
assert(f.is_open());
assert(f.is_readable());
f << "hello world";
 
// par 
 
valide_ofstream f { ... };
f << "hello world";

En utilisant les opérateurs de flux « pour l'écriture et » pour la lecture. (attention a ce que le fichier soit ouvert avec le “bon” mode).

Par exemple, pour écrire une liste de valeur, séparé par un espace :

file << i << ' ' << j << ' ' << k << endl;

Remarque : avec mode texte, les chiffres sont écrit les uns à la suite des autres. Si on écrit :

file << 1;
file << 2;
file << 3;

cela produit dans le fichier “123”. Si on essaie de lire, on lira qu'un seul nombre (123). Donc penser à ajouter des séparateurs.

Pour la lecture :

file >> i;

Problème de séparation des caractères. De lecture d'une ligne

lecture complet dans un string ?

Caractère spéciaux : tabulation \t retour à la ligne \n

Problème lecture windows/linux : \n et \r\n

ouverture et fermeture manuelle ? (open, is_open, close)

Se positionner dans un fichier ? (eof, fpos, etc.)

Note : n'oubliez pas que les flux utilisent en général un tampon mémoire (buffer)

Gestion des erreurs, exceptions

Permettre la lecture et l'écriture de fichiers. 2 types de fichiers : binaire et texte. Déjà vu les différentes représentation d'un nombre, en binaire :

main.cpp

#include <iostream>
#include <bitset>
 
int main() {
    int const i { 123456 };
    std::cout << "représentation numérique: " << i << std::endl;
    std::cout << "représentation binaire: " << std::bitset<sizeof(i)*8>(i) << std::endl;
    std::cout << sizeof(123) << std::endl;
    std::cout << sizeof("123") << std::endl;
    std::cout << sizeof(123456) << std::endl;
    std::cout << sizeof("123456") << std::endl;
    std::cout << sizeof(123456789) << std::endl;
    std::cout << sizeof("123456789") << std::endl;
}

affiche :

représentation numérique: 123456
représentation binaire: 00000000000000011110001001000000
4
4
4
7
4
10

En mode texte, chaque chiffre prend 1 octet (+ un octet de fin de chaîne), en binaire, toujours la même taille pour un int. Donc fichier texte permet d'être lu avec un simple éditeur, mais plus gros en taille.

• fichier csv (comma separated values) : tableau avec séparation par ,
• fichier texte excel : tabulation + retour à la ligne
• génération xml
• génération json
• lecture et écriture image ?