Différences

Cette page vous donne les différences entre la révision choisie et la version actuelle de la page.

--- fichier [2016/04/25 20:04]
gbdivers
+++ fichier [2016/05/08 18:13] (Version actuelle)
gbdivers
@@ Ligne 6: / Ligne 6: @@
 ====== Les fichiers ======
-===== Représentation binaire et texte =====
+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>''.
-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 :
+===== Création et ouverture de fichier =====
+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" :
 <code cpp main.cpp>
 #include <iostream>
-#include <bitset>
+#include <fstream>
 int main() {
-    int const i { 123456 };
+    std::ofstream file { "test.txt" };
-    std::cout << "représentation numérique: " << i << std::endl;
+    return 0;
-    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;
 }
 </code>
-affiche :
+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.
 <code>
-représentation numérique: 123456
+clang++ -std=c++14 -Wall -Wextra -pedantic main.cpp && ./a.out && ls
-représentation binaire: 00000000000000011110001001000000
 </code>
-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.
+Si vous commentez la ligne de code contenant la variable ''file'' (en ajoutant ''/ /'' au début de la ligne), la fonction ''ls'' affiche :
-===== Création et ouverture de fichier =====
+<code>
+a.out
+main.cpp
+</code>
+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 :
+<code>
+a.out
+main.cpp
+test.txt
+</code>
+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'' :
-Utilisation de stream, comme pour ''cout'' et ''cin'', avec ''&lt;&lt;'' pour écrire et ''>;>;'' pour lire.
+  * création du fichier &quot;test.txt&quot; ;
+  * ouverture de ce fichier ;
+  * création d'un flux pour écrire sur ce fichier.
-Utiliser fstream pour lecture et/ou écriture ("file stream") ou classes plus spécialisées ofstream ("output file stream") et ifstream ("input file stream").
+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.
-On peut simplement ouvrir un fichier en créant un ifstream :
+Pour la variable ''std::ofstream'', cela veut dire qu'elle est détruite à la fin de la fonction ''main''.
 <code cpp>
+int main() {
+    std::ofstream file { "test.txt" };  // création de la variable "file"
+    return 0;
+}                                       // destruction de la variable "file"
+</code>
+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.
+<note>**Resource Acquisition Is Initialization**
+Cette approche, qui consiste à faire tout ce qui est nécessaire pour qu'une variable soit directement utilisable lors de sa création (acquisition des ressources) et tout ce qui est nécessaire pour libérer correctement les ressources lorsque la variable est détruite est un concept très important en C++. Tellement important qu'il a un nom : "Resource Acquisition Is Initialization" (RAII).
+Couplé avec l'utilisation des variables locales, qui permettent de détruite automatiquement les variables (et donc libérer automatiquement les ressources), et vous avez le moyen le plus simple et le plus sûr pour gérer les ressources en C++.
+Ce concept sera détaillé dans la partie sur la programmation orientée objet.</note>
+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.
+<code cpp main.cpp>
+#include <iostream>
 #include <fstream>
 int main() {
-    std::ifstream text_file("in.txt"); // mode texte
+    {
-    std::ifstream binary_file("in.bin", std::ios::binary);  // mode binaire
+        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;
 }
 </code>
-Le fichier est automatiquement enregistré et fermée lorsque les variable text_file et binary_file sont détruite (donc à la fin du bloc). En utilisant la portée des variables, on peut donc décider quand les fichiers sont ouvert et fermé :
-<code cpp>
+===== Ecriture et lecture de données =====
+Une fois que le fichier est ouvert en écriture avec ''std::ofstream'', vous pouvez écrire directement dedans en utilisant l'opérateur ''<<''.
+<code cpp main.cpp>
+#include <iostream>
 #include <fstream>
 int main() {
-    cout << "pas encore ouvert" << endl;
+    std::ofstream file { "test.txt" };
-    {
+    file << "Hello word! " << std::endl;
-        cout << "ouverture du fichier" << endl;
+    file << 1234 << std::endl;
-        std::ifstream file("in.txt");
+    return 0;
-    } // fermeture du fichier
-    cout << "le fichier est fermé" << endl;
 }
 </code>
-De la même façon, pour ouvrir un fichier en écriture :
+Pour voir le contenu du fichier sur Coliru.com, vous pouvez utiliser la commande "cat nom_fu_fichier" à la place de "ls".
+<code>
+clang++ -std=c++14 -Wall -Wextra -pedantic main.cpp && ./a.out && cat test.txt
+</code>
+affiche :
+<code>
+Hello word!
+
+</code>
+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.
+L’écriture sur un flux suit donc la forme générale suivante, pour envoyer une ou plusieurs valeurs.
+<code>
+FLUX << DATA;
+FLUX << DATA << DATA << DATA << DATA ...
+</code>
+Pour lire un flux, vous avez déjà également vu que la forme générale est la suivante :
+<code>
+FLUX >> DATA;
+FLUX >> DATA >> DATA >> DATA >> DATA ...
+</code>
+Une différence importante entre un flux en lecture et un flux en écriture est qu'il est pas possible de lire des données vers une littérale (une littérale est toujours une valeur constante).
 <code cpp>
+int x { 123 };
+file << x;    // ok
+file >> x;    // ok
+file << 123;  // ok
+file >> 123;  // erreur
+</code>
+Pour lire les données depuis un fichier, vous pouvez donc créer un flux de type ''std::ifstream'' et utiliser l'opérateur ''>>''.
+<code cpp main.cpp>
+#include <iostream>
 #include <fstream>
 int main() {
-    std::ofstream file("out.txt");
+    std::ifstream file { "test.txt" };
+    std::string s {};
+    file >> s;
+    return 0;
 }
 </code>
-Si le fichier n'existe pas, il est créé.
+<note>Sur Coliru.com, à chaque fois que vous compiler un programme, l'espace de travail est nettoyé. Cela signifie que si vous écrivez un premier code utilisant ''std::ofstream'' pour créer un fichier, que vous l'exécutez, puis que vous créer un nouveau code utilisant ''std::ifstream'' pour lire le fichier créé, ce dernier ne sera plus disponible.
+Pour tester l'utilisation des fichiers sur Coliru.com, il est donc préférable d'écrire et lire un fichier dans un même programme. Dans la suite de ce cours, les codes d'exemples seront généralement écrit pour être exécuté sur Coliru.com, ce qui signifie que les codes contiendront une première série de ligne pour créer un fichier, puis les lignes de code pour lire ce fichier.</note>
+<code cpp main.cpp>
+#include <iostream>
+#include <fstream>
+int main() {
+    {   // creation du fichier
+        std::ofstream out { "test.txt" };
+        out << 123 << std::endl;
+    }
+    std::ifstream in { "test.txt" };
+    int i {};
+    in >> i;
+    std::cout << i << std::endl;
+    return 0;
+}
+</code>
+affiche :
+<code>
+
+</code>
+===== Ecrire plusieurs valeurs, espaces et retours a la ligne =====
+Comme pour les autres flux en lecture, il est possible de lire plusieurs données dans un flux ''ifstream'' (Heureusement ! L’intérêt des fichiers seraient limité si il n’était possible d’écrire qu'une seule valeur par fichier).
+==== Avec des nombres entiers ====
+Si vous ajoutez plusieurs valeurs dans le code précédent, vous écrirez probablement le code suivant :
+<code cpp main.cpp>
+#include <iostream>
+#include <fstream>
+int main() {
+    {   // creation du fichier
+        std::ofstream out { "test.txt" };
+        out << 123 << 456 << 789 << std::endl;
+    }
+    std::ifstream in { "test.txt" };
+    int i {};
+    in >> i;
+    std::cout << i << std::endl;
+    in >> i;
+    std::cout << i << std::endl;
+    in >> i;
+    std::cout << i << std::endl;
+    return 0;
+}
+</code>
+Malheureusement, ce code n'affiche pas trois valeurs, comme vous pouvez vous y attendre, mais une seule valeur.
+<code>
+123456789
+</code>
+Si vous utiliser la commande ''cat'' pour voir le contenu du fichier, vous voyez qu'il contient également qu'un seule valeur. Et bien sur, lors de la lecture d'un tel fichier, il n'est pas possible de savoir que vous avez écrit trois valeurs de trois chiffres, ou neuf valeurs de un chiffre, ou encore une valeur de neuf chiffres.
+Modifiez le code pour ajouter un retour a la ligne ou un espace entre deux valeurs.
+<code cpp main.cpp>
+#include <iostream>
+#include <fstream>
+int main() {
+    {   // creation du fichier
+        std::ofstream out { "test.txt" };
+        out << 123 << ' ' << 456 << std::endl;
+        out << 789 << std::endl;
+    }
+    std::ifstream in { "test.txt" };
+    int i {};
+    in >> i;
+    std::cout << i << std::endl;
+    in >> i;
+    std::cout << i << std::endl;
+    in >> i;
+    std::cout << i << std::endl;
+    return 0;
+}
+</code>
+Maintenant, la commande ''cat'' indique que le fichier contient le texte suivant (ce qui correspond a ce que vous pouviez vous attendre) :
+<code>
+456
+
+</code>
+Le programme affiche :
+<code>
+
+
+
+</code>
+Donc, dans ce code, la lecture du fichier est correcte et chaque valeur est lue individuellement. Les espaces et les retours a la ligne sont reconnus comme des séparateurs de valeurs et ''ifstream'' lit correctement le fichier.
+==== Avec des nombres réels ====
+Les flux permettent également d'utiliser des nombres réels et reconnaissent l’écriture scientifique.
+<code cpp main.cpp>
+#include <iostream>
+#include <fstream>
+int main() {
+    {   // creation du fichier
+        std::ofstream out { "test.txt" };
+        out << 123.4546 << std::endl;
+        out << 123.456e78 << std::endl;
+    }
+    std::ifstream in { "test.txt" };
+    double x {};
+    in >> x;
+    std::cout << x << std::endl;
+    in >> x;
+    std::cout << x << std::endl;
+    return 0;
+}
+</code>
+affiche :
+<code>
+.455
+.23456e+80
+</code>
+Vous voyez ici que la seconde valeur n'utilise pas le même format d'affichage que celui utilisée dans le code (et dans le fichier). La raison est que les valeurs n'ont pas de format d'affichage a proprement parlé. Ce sont les flux qui affichent les valeurs réelles en utilisant un format (que vous pouvez modifier, pour rappel, voir [[nombres_reels|]]).
+Donc la littérale "123.456e78" dans le code est convertie en une valeur qui ne possède pas de format lorsque le code est compilé. Puis l’écriture de cette valeur dans un fichier utilise le format par défaut de ''std::ofstream''. Cette valeur formatée dans le fichier est ensuite lue par ''std::ifstream'' (qui reconnait ce format) et est enregistrée dans la variable ''x'' sans son format. Et pour terminer, le flux ''std::cout'' affiche la valeur en utilisant son propre format par défaut.
+L'alternance d’étapes qui ne conservent pas le format et de flux qui possèdent leur propre format par défaut explique que la valeur dans le code n'a pas le même format que la valeur affichée au final. Dans la majorité des cas, ce comportement par défaut convient et facilite les lectures et écritures de données.
+En cas de probleme de lecture, n’hésitez pas a vérifier les formats utilisés en lecture et écriture.
+Il faut egalement faire attention a ne pas melanger les nombres entiers et reels. Si vous essayez de lire un fichier contenant une valeur reelle pour l'enregistrer dans une variable entiere, le comportement sera indetermine.
+<code cpp main.cpp>
+#include <iostream>
+#include <fstream>
+int main() {
+    {   // creation du fichier
+        std::ofstream out { "test.txt" };
+        out << 123.456e78 << std::endl;
+    }
+    std::ifstream in { "test.txt" };
+    int i {};
+    in >> i;
+    std::cout << i << std::endl;
+    return 0;
+}
+</code>
+affiche :
+<code>
+
+</code>
+L'inverse ne pose pas de probleme, un nombre entier est une forme particuliere de nombre reel (pour lequel la partie decimale est nulle).
+==== Avec des chaines de caractères ====
+probleme avec les espaces. Utilisation de getline
+===== Options d'ouverture =====
 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 :
@@ Ligne 154: / Ligne 447: @@
 ===== Ecriture et lecture =====
-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 :
-<code cpp>
-file << i << ' ' << j << ' ' << k << endl;
-</code>
-Remarque : avec mode texte, les chiffres sont écrit les uns à la suite des autres. Si on écrit :
-<code cpp>
-file << 1;
-file << 2;
-file << 3;
-</code>
-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 :
-<code>
-file >> i;
-</code>
 Problème de séparation des caractères. De lecture d'une ligne
@@ Ligne 189: / Ligne 459: @@
 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
+===== Format texte et binaire =====
+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 :
+<code cpp 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;
+}
+</code>
+affiche :
+<code>
+représentation numérique: 123456
+représentation binaire: 00000000000000011110001001000000
+</code>
+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.
 ===== Pratiquer =====

C++, Qt, OpenGL, CUDA

Outils d'utilisateurs

Outils du Site

Différences

Outils de la Page