3.flux.md

Flux d'entrée / sortie

• En C++, un flux est une séquence d’octets (byte en anglais, à ne pas confondre avec bit : 1 octet = 1 byte = 8 bits).
• Les flux “s’écoulent” des périphériques vers la mémoire pour les processus d’entrées (clavier, souris, disque dur, ...), et de la mémoire vers les périphériques pour la sortie (écran, disque dur, imprimante, ...). Pour les entrées – sorties standards :

#include <iostream>

• Rappel sur le flux d’entrée-sortie standard:
  • Entrée standard au clavier avec cin.
  • Sortie standard à l’écran (console) avec cout.
  • Le flux suit la direction des chevrons.

#include <iostream> // pour std::cout , std::cin et std::endl
std::cout << " Saisirs 3 entiers : " << std::endl ;
int a, b, c ;
std::cin >> a >> b >> c;

Formatage

• Formatage en sortie
  • Les formatages sont accessibles grâce au header iomanip.
  • Tous les formatages sont gardés en mémoire jusqu’à ce qu’une autre option change le formatage.

# include <iostream> // pour std::cout , std::cin et std::endl
# include <iomanip>

int n = 255; double e = 2.718281828;
std::cout << n << std::endl ; // par défaut en décimal
std::cout << hex << n << std::endl ; // en hexadécimal
std::cout << dec << n << std::endl ; // en décimal
std::cout << setw(15) << n; // la prochaine sortie est de 15 caractères
std::cout << setfill('0') << n; // remplit les blancs avec le caractère ’0’
std::cout << setprecision (6) << e << std::endl ; // nombres de chiffres significatifs ou de décimales (si fixed est utilise)
std::cout << fixed << e << std::endl ; // nombre de décimales fixe
std::cout << scientific << e << std::endl ; // notation scientifique
bool ok = std::cout.good (); // verifie que l’etat du flux est ok , i.e. on peut effectuer des operations d’entree / sortie dessus. Idem avec std::cin

Ecriture

• Manipulation des fichiers textes:
  • Il faut un flux par fichier
  • ofstream pour écrire dans un fichier
  • ifstream pour lire un fichier

#include <fstream>
int main(){
    ofstream fout ; // On crée un flux de sortie que l’on nomme fout  
    fout.open("/tmp/test.txt") ; // On branche le flux à notre fichier si le fichier est dans le même répertoire que le programme, le nom suffit.Sinon on met le chemin complet
    if(!fout){//Si l’ouverture n’a pas fonctionné
        std::cout << "Pb à l’ouverture";
        return 1 ; 
    }

    fout << "Hello world" ; //écriture de Hello world dans le fichier  
}

#include <fstream> 
 
int main() { 
    ofstream monFlux("/tmp/test.txt"); //Déclaration  et ouverture d'un flux permettant d'écrire dans le fichier

    monFlux << "Du texte dans le fichier" << std::endl; //Ecrit dans le fichier

    monFlux.close(); //ferme le flux avant la sortie du bloc , donc l’accès au fichier

    monFlux.open("unAutre.txt"); //ouverture d’un autre fichier sur le même flux

    std::string const nomFichier("/tmp/unAutreFichier.txt");

    ofstream monAutreFlux(nomFichier.c_str()); //pour ouvrir un fichier depuis une chaîne de caractère */

    ofstream fluxAjout("/tmp/test.txt", ios::app); //on écrit à la fin du fichier sans l’écraser
    return 0; 
}

Lecture

#include <fstream> 
#include <string>

int main() { 
    ifstream monFlux("D:/test.txt"); //Déclaration et ouverture d'un flux permettant de lire le fichier
    std::string ligne; 
    getline(monFlux, ligne); //On lit une ligne complète du fichier
    std::string mot; 
    monFlux >> mot; //on lit un mot du fichier	
    char a; 
    monFlux.get(a); //on lit un caractère du fichier pour lire un fichier en entier, on teste si on est arrivé au bout
    while(getline(monFlux, ligne)) //Tant qu'on n'est pas a la fin, on lit 
    {
            std::cout << ligne << std::endl;
    }
    return 0; 
}

Fichier binaire

• Les données sont lues/écrites par séquences d’octets On ne peut lire et écrire que les types de bases (int, char,…)
• La taille des fichiers est plus petite
• Les accès sont plus rapide qu’avec un fichier texte
• Il faut savoir comment le fichier a été écrit pour pouvoir le lire
• Lors de l’ouverture on utilise ios::binary
• La lecture et l’écriture se font avec write et read

ofstream fluxEcriture("/tmp/test.tif ", ios::binary);
int i =3; //i doit être de type simple
fluxEcriture.write( (char*)&i, sizeof(i)) ; //on caste i en char* et on précise la taille prise en mémoire 
ifstream fluxLecture("/tmp/test.tif " , ios::binary);
int i;
fluxLecture.read((char*)&i, sizeof(i));

Exercice 5