Dans ce laboratoire, vous allez apprendre la mise en forme, l'entrée/sortie de fichiers et l'espace de noms en C++. Vous allez apprendre comment formater la sortie, comment formater l'entrée, comment lire et écrire dans des fichiers, et comment utiliser les espaces de noms.
Utilisez les manipulateurs d'entrée/sortie <iomanip> pour formater l'entrée et la sortie.
Le fichier d'en-tête <fstream> fournit ifstream (flux de fichier d'entrée) et ofstream (flux de fichier de sortie) pour l'entrée et la sortie de fichiers.
Le fichier d'en-tête <iomanip> fournit les soi-disant manipulateurs d'entrée/sortie pour formater l'entrée et la sortie :
setw(int largeur_de_champ) : définit la largeur de champ pour la prochaine opération d'entrée/sortie. setw() n'est pas persistant et doit être utilisé avant chaque opération d'entrée/sortie. La largeur de champ est réinitialisée à la valeur par défaut après chaque opération (avec une largeur suffisante pour accueillir le champ).setfill(char caractere_de_remplissage) : définit le caractère de remplissage pour le remblayage jusqu'à la largeur de champ.left|right|internal : définit l'alignementfixed/scientific (pour les nombres à virgule flottante) : utilise la notation à virgule fixe (par exemple, 12,34) ou la notation scientifique (par exemple, 1,23e+006).setprecision(int nombre_de_digits_apres_la_virgule) (pour les nombres à virgule flottante) : spécifie le nombre de chiffres après la virgule.boolalpha/noboolalpha (pour bool) : affiche les valeurs bool sous forme de chaîne alphabétique (true/false) ou 1/0./* Test Formatting Output */
#include <iostream>
#include <iomanip> // Nécessaire pour effectuer une entrée/sortie formatée
using namespace std;
int main() {
// Nombres à virgule flottante
double pi = 3.14159265;
cout << fixed << setprecision(4); // Format fixe avec 4 chiffres après la virgule
cout << pi << endl;
cout << "|" << setw(8) << pi << "|" << setw(10) << pi << "|" << endl;
// setw() n'est pas persistant, ne s'applique qu'à la prochaine opération.
cout << setfill('-');
cout << "|" << setw(8) << pi << "|" << setw(10) << pi << "|" << endl;
cout << scientific; // En format scientifique avec exposant
cout << pi << endl;
// booléens
bool termine = false;
cout << termine << endl; // Affiche 0 (pour false) ou 1 (pour true)
cout << boolalpha; // Affiche true ou false
cout << termine << endl;
return 0;
}Sortie :
3.1416
| 3.1416| 3.1416|
|--3.1416|----3.1416|
3.1416e+00
0
false
/* Test Formatting Input */
#include <iostream>
#include <iomanip>
#include <string>
using namespace std;
int main() {
string code_region, code_telephone;
string chaine_entree;
cout << "Entrez votre numéro de téléphone au format (xxx)xxx-xxxx : ";
cin.ignore(); // Passe le '('
cin >> setw(3) >> code_region;
cin.ignore(); // Passe le ')'
cin >> setw(3) >> code_telephone;
cin.ignore(); // Passe le '-'
cin >> setw(4) >> chaine_entree;
code_telephone += chaine_entree;
cout << "Numéro de téléphone : (" << code_region << ")"
<< code_telephone.substr(0, 3) << "-"
<< code_telephone.substr(3, 4) << endl;
return 0;
}Sortie :
Entrez votre numéro de téléphone au format (xxx)xxx-xxxx : 254 845 9946
Numéro de téléphone : (254)845-9946
Pour tester l'entrée et la sortie de fichiers, créez tout d'abord un fichier appelé in.txt et écrivez quelques nombres entiers dans celui-ci, séparés par des espaces. Après l'exécution, le résultat du calcul sera écrit dans un fichier out.txt.
/* Test File I/O
Read all the integers from an input file and
write the average to an output file */
#include <iostream>
#include <fstream> // file stream
#include <cstdlib>
using namespace std;
int main() {
ifstream fin; // Flux d'entrée
ofstream fout; // Flux de sortie
// Essayez d'ouvrir le fichier d'entrée
fin.open("in.txt");
if (!fin.is_open()) {
cerr << "error: open input file failed" << endl;
abort(); // Terminez anormalement le programme (dans <cstdlib>)
}
int somme = 0, nombre, compteur = 0;
while (fin >> nombre) {
// Utilisez >> pour lire
cout << nombre << " ";
somme += nombre;
++compteur;
}
double moyenne = double(somme) / compteur;
cout << "Compteur = " << compteur << " moyenne = " << moyenne << endl;
fin.close();
// Essayez d'ouvrir le fichier de sortie
fout.open("out.txt");
if (!fout.is_open()) {
cerr << "error: open output file failed" << endl;
abort();
}
// Écrivez la moyenne dans le fichier de sortie en utilisant <<
fout << moyenne;
fout.close();
return 0;
}Sortie :
12 15 35 26 68 Compteur = 5 moyenne = 31.2
Notes du programme :
>> et << pour l'entrée et la sortie, de manière similaire à cin >> et cout <<. (Note avancée : ifstream est une sous-classe de istream, auquel appartient cin. ofstream est une sous-classe de ostream, auquel appartient cout.)fixed, setprecision() et setw(), fonctionnent sur les flux de fichiers.Lorsque vous utilisez différents modules de bibliothèque, il existe toujours un risque de collision de noms, car différentes bibliothèques peuvent utiliser le même nom pour différents buts. Ce problème peut être résolu en utilisant l'espace de noms en C++. Un espace de noms est une collection d'identificateurs dans la même portée de nommage. (Il est connu sous le nom de package en UML et Java.) Le nom de l'entité dans un espace de noms est qualifié par le nom de l'espace de noms, suivi de :: (appelé opérateur de résolution de portée), sous la forme espace_de_noms::nom_d_entité.
Pour placer une entité dans un espace de noms, utilisez le mot-clé espace de noms comme suit :
// crée un espace de noms appelé myNamespace pour les entités incluses
namespace myNameSpace {
int foo; // variable
int f() { ...... }; // fonction
class Bar { ...... }; // type composé tel que classe et struct
}
// Pour référencer les entités, utilisez
myNameSpace::foo
myNameSpace::f()
myNameSpace::BarUn espace de noms peut contenir des variables, des fonctions, des tableaux et des types composés tels que des classes et des structures.
#include <iostream>
namespace a { // contient des variables
int i1 = 8;
int i2 = 9;
}
namespace b { // contient une fonction
int max(int n1, int n2) {
return (n1 > n2)? n1 : n2;
}
}
int main() {
std::cout << a::i1 << std::endl; // 8
std::cout << b::max(a::i1, a::i2) << std::endl; // 9
}Sortie :
8
9
Utilisation de l'espace de noms
// Utilisez les noms entièrement qualifiés,
// tels que std::cout, std::endl, std::setw() et std::string.
std::cout << std::setw(6) << 1234 << std::endl;
// Utilisez une déclaration using pour déclarer les identificateurs particuliers.
using std::cout;
using std::endl;
......
cout << std::setw(6) << 1234 << endl;
// Utilisez une directive using namespace.
using namespace std:
......
cout << setw(6) << 1234 << endl;
// Pour un nom d'espace de noms long, vous pouvez définir un raccourci (ou un alias) pour l'espace de noms
namespace raccourci = nom_de_l_espace_de_noms;Les étapes pour l'entrée/sortie de fichiers sont les suivantes :
ifstream pour l'entrée, ou un ofstream pour la sortie.open(nom_du_fichier).<<, ou une entrée via l'opérateur d'extraction de flux >>, de manière similaire à cout << et cin >>.En C++, une entité (variable, fonction ou classe) appartient à l'espace de noms global (identifié par :: sans nom d'espace de noms).
