Programmation orientée objet C++
参考书目：《C++面向对象程序设计》—— 谭浩强 《C++程序设计：思想与方法》—— 翁惠玉
Chapitre 7 : Flux d'entrée et de sortie
1. Flux d'entrée standard
En C++, les entrées et sorties se font via des flux. L'opération de sortie de C++ convertit l'état d'un objet en une séquence de caractères et l'affiche quelque part. L'opération de saisie reçoit une séquence de caractères de quelque part, puis la convertit au format requis par l'état d'un objet.
L'endroit où les données de sortie sont reçues et stockées est appelé cible, et l'endroit d'où proviennent les données d'entrée est appelé source.Les opérations d'entrée et de sortie peuvent être considérées comme le flux de séquences de caractères entre la source, la cible et l'objet. Le système de classes qui effectue les opérations d'entrée et de sortie est appelé classe de flux, et le système qui fournit l'implémentation de la classe de flux est appelé bibliothèque de classes de flux.
注：此图是简化的流类库的基本类等级图，而不是直接的继承关系图。其实它们都是模板类，箭头表示的是类等级关系。
这个等级关系在头文件iostream.h中说明。在图中，ios类中一个指针成员指向streambuf类的对象。Streambuf类管理流的缓冲区。由于数据隐蔽和封装的需要，普通用户只使用ios、istream和ostream类提供的公有接口，完成流的提取和插入操作。
ios类是istream类和ostream类的虚基类，提供对流的格式化I/O操作和错误处理的成员处理的成员函数。从ios类公有派生istream类和ostream类分别提供对流进行提取和插入操作的成员函数，而iostream类通过组合istream类和ostream类支持对一个流进行双向操作，它并没有提供新成员函数。
iostream中预定义四个流对象，它们分别是cin、cout、cerr、clog。事实上可以将cin视为istream的一个对象，而cout视为ostream的一个对象。流是一个抽象的概念，当实际进行I/O操作时，必须将流和一个具体的物理设备连接起来。
Les appareils connectés aux quatre flux prédéfinis par la bibliothèque de classes de flux C++ sont présentés dans le tableau :
| couler | équipement |
|---|---|
| cin | périphérique d'entrée standard |
| cout | périphérique de sortie standard |
| cerr | Périphérique de sortie d'erreur standard (mode sans tampon) |
| sabot | Périphérique de sortie d'erreur standard (mode tampon) |
Fichiers d'en-tête liés à la bibliothèque de classes iostream : Les déclarations des différentes classes de la bibliothèque de classes iostream sont placées dans différents fichiers d'en-tête. Lorsque l'utilisateur utilise la commande #include pour inclure les fichiers d'en-tête requis dans le programme, cela équivaut à déclarer tous les fichiers d'en-tête requis dans le programme.classe requise.
-
Opérations de flux d'entrée et de sortie iostream
-
fstream gère les opérations d'E/S de fichiers
-
opérations d'E/S du flux de caractères strstream
-
stdiostream Mélange C et C++
-
iomanip utilise des opérations d'E/S formatées
注：已在iostream头文件中重载了>> 和<<运算符。用于标准类型数据的输入和输出。
2. Flux de sortie standard
1. Utilisez des caractères de contrôle pour définir la base de données dans le flux de sortie
La classe ostream définit trois objets stream : cout, cerr et clog.
- L'objet cout stream
cout stream ouvre un tampon en mémoire pour stocker les données dans le flux. Lorsque endl est rencontré, toutes les données du flux sont immédiatement sorties, puis un caractère de nouvelle ligne est inséré et le tampon est effacé. - Objet flux cerr
L'objet flux cerr est le flux d'erreurs standard. Il envoie des informations sur l'erreur au périphérique d'erreur standard.
Exemple : Écrivez un programme pour saisir les valeurs de a, b et c à partir du clavier afin de résoudre l'équation quadratique ax2+bx+c=0. Si a=0 ou la valeur du discriminant b2-4ac<0, un message d'erreur est émis.
int main()
{
float a, b, c, disc;
cout << "请输入 a,b,c:";
cin >> a >> b >> c;
if (a == 0)
cerr << "a 等于0，错误!" << endl;
else if ((disc = b * b - 4 * a*c) < 0)
cerr << "判别式b*b-4*a*c<0"<<endl;
else
{
cout << "x1=" << (-b + sqrt(disc)) / (2 * a) << endl;
cout << "x2=" << (-b - sqrt(disc)) / (2 * a) << endl;
}
return 0;
}
- Objet Clog Stream
L'objet Clog Stream est également un flux d'erreur standard. La différence entre lui et cerr est que cerr génère directement les informations d'erreur sur l'écran sans passer par le tampon. Clog stocke les informations d'erreur dans le tampon et les envoie à l'écran. lorsque le tampon est plein ou que endl est rencontré. Message d'erreur de sortie.
Exemple : utilisez des caractères de contrôle pour contrôler le format de sortie.
#include <iostream>
#include <iomanip>
#include<string>
using namespace std;
int main()
{
int a;
cout << "input a:";
cin >> a;
cout << "dec:" << dec << a << endl;
cout << "hex:" << hex << a << endl;
cout << "oct:" << setbase(8) << a << endl;
char *pt = (char *)"China";
cout << setw(10) << pt << endl;
cout << setfill('*') << setw(10) << pt << endl;
double pi = 22.0 / 7.0; cout << setiosflags(ios::scientific) << setprecision(8);
cout << "pi=" << pi << endl;
cout << "pi=" << setprecision(4) << pi << endl;
cout << "pi=" << setiosflags(ios::fixed) << pi << endl;
return 0;
}
2. Utilisez la fonction membre stream pour définir la base de données dans le flux de sortie
Les fonctions membres courantes utilisées pour contrôler le format de sortie sont présentées dans le tableau 7.4 :
fonction membre de flux setf et symbole de contrôle setiosflags. Les paramètres entre parenthèses sont des indicateurs de format, qui sont définis dans la classe ios en tant que valeurs d'énumération. Par conséquent, lorsque vous faites référence à ces indicateurs de format, commencez par ios::. Les indicateurs de format sont répertoriés dans le tableau 7.5 :
Exemple : utilisez la fonction membre de contrôle de flux pour générer des données.
int main()
{
int a = 21;
cout.setf(ios::showbase);
cout << "dec:" << a << endl;
cout.unsetf(ios::dec);
cout.setf(ios::hex);
cout << "hex:" << a << endl;
cout.unsetf(ios::hex);
cout.setf(ios::oct);
cout << "oct:" << a << endl;
char *pt =(char *) "China";
cout.width(10);
cout << pt << endl;
cout.width(10);
cout.fill('*');
cout << pt << endl;
double pi = 22.0 / 7.0;
cout.setf(ios::scientific);
cout << "pi=";
cout.width(14);
cout << pi << endl;
cout.unsetf(ios::scientific);
cout.setf(ios::fixed);
cout.width(12);
cout.setf(ios::showpos);
cout.setf(ios::internal);
cout.precision(6);
cout << pi << endl;
return 0;
}
3. Objets de flux
1.cin flux
cin est un objet de la classe istream qui lit les données du périphérique d'entrée standard. Opérateur d'extraction de flux >> ignore généralement les caractères tels que les espaces, les touches de tabulation, les nouvelles lignes, etc. dans le flux lors de l'extraction des données du flux. Seules les données saisies lors de la saisie de la touche Entrée entrent dans le tampon du clavier, formant un flux d'entrée à partir duquel l'opérateur d'extraction peut extraire des données.
Lorsqu'un caractère invalide (incohérent avec le type de données variable) ou la fin du fichier est rencontré, le flux d'entrée cin est dans un état d'erreur et toutes les opérations sur le flux cin sont terminées. Lorsqu'il y a une erreur dans le flux d'entrée, la valeur de cin est fausse, vous pouvez donc juger si l'objet du flux est dans un état normal en fonction de la valeur de cin.
Exemple : testez la valeur de cin et déterminez l'état de l'objet flux.
int main()
{
float grade;
cout << "enter grade:";
while (cin >> grade)
{
if (grade >= 85)
cout << grade << " GOOD!" << endl;
if (grade < 85 && grade >= 60)
cout << grade << " Just so so!" << endl;
if (grade < 60)
cout << grade << " fail!" << endl;
cout << "enter grade:";
}
cout << "The end." << endl;
return 0;
}
2. Fonction membre Stream pour les caractères d'entrée
- Utilisez la fonction get pour lire un
format de caractère :
le type de la fonction cin.get() est caractère, et la fonction de la fonction est d'extraire un caractère du flux d'entrée et de le renvoyer sous forme de valeur de fonction. Si le caractère de fin de fichier EOF est rencontré dans le flux, -1 est renvoyé.
int main()
{
char c;
cout << "enter a sentence:" << endl;
while ((c = cin.get()) != EOF)
cout.put(c);
return 0;
}
- Le format de la fonction get à un paramètre
: cin.get (variable caractère)
extrait un caractère du flux d'entrée et l'affecte à la variable caractère. Si le caractère de fin de fichier est rencontré, l'extraction se termine. Entrez la Entrée suivie du caractère de fin de fichier.
int main()
{
char c;
cout << "enter a sentence:" << endl;
while (cin.get(c)) {
cout.put(c); }
cout << "end" << endl;
return 0;
}
- Le format de la fonction get à trois paramètres
: cin.get (pointeur de caractère, n, caractère de fin)
n est lié au nombre de caractères extraits. La fonction extrait séquentiellement jusqu'à n-1 caractères du tampon du clavier et les place séquentiellement dans le tableau de caractères pointé par le pointeur de caractère. Si un caractère de fin est rencontré pendant le processus d'extraction, l'extraction sera terminée, que le nombre de caractères spécifié soit ou non atteint.
void main()
{
char ch[20];
cout << "enter a sentence:" << endl;
cin.get(ch, 10, '\n');
cout << ch << endl;
}
- Utilisez la fonction membre getline pour lire une ligne de caractères.
Format : cin.getline (pointeur de caractère, n, caractère de fin).
La fonction function est similaire à la fonction get avec trois paramètres.
Les similitudes et les différences entre cin.get et cin.getline avec trois paramètres :
La même chose est qu'ils n'ignorent pas les caractères d'espacement rencontrés lors du processus d'extraction et arrêtent l'extraction lorsqu'un caractère de fin est rencontré.
La différence est que lors de l'arrêt de l'extraction, cin.getline déplacera le pointeur vers les octets adjacents après le caractère de fin, mais pas la fonction cin.get avec trois paramètres.
int main()
{
char ch[20];
char c1;
cout << "输入一句话:" << endl;
cin >> ch;
cout << "第一次 cin 提取的字符串是:" << ch << endl;
c1 = cin.get();
cout << "第二次 cin.get() 提取的字符串是:" << c1 << endl;
cin.get(c1);
cout << "第三次 cin.get(c1) 提取的字符串是:" << c1 << endl;
cin.get(ch, 20, '/');
cout << "第四次 cin.get( ch, 20, '/') 提取的字符串是:" << ch << endl;
cin.getline(ch, 20, '/');
cout << "第五次 cin.getline (ch,20,'/')提取的字符串是:" << ch << endl;
cin.getline(ch, 20, '/');
cout << "第六次 cin.getline (ch,20,'/')提取的字符串是:" << ch << endl;
return 0;
}
注：cin和cin.getline都具有从键盘缓冲区按指针所指提取字符串的功能。它们有以下区别：
1.cin忽略起始的空白字符；而cin.getline不忽略起始的空白字符。
2.cin当提取到非空白字符后，遇到空白字符时就终止提取，指针就停留在空白字符处；而cin.getline是提取到规定的终止字符或规定的字符个数后终止提取，指针停留在提取的最后一个字符后面相邻的字节。
3.通过对>> 的重载，cin可以提取其他类型的数据；而cin.getline只能输入字符串。
3. Autres fonctions de la classe istream
La fonction eof()
est vraie lorsque le pointeur du tampon d'entrée rencontre le caractère de fin de fichier, sinon elle est fausse. Utilisez ctrl+z pour saisir le caractère de fin de fichier à l'aide du clavier.
Exemple : saisissez une chaîne à l'aide du clavier, utilisez le caractère de fin de fichier comme marque de fin et affichez les caractères autres que des espaces un par un.
void main()
{
char c;
while (!cin.eof())
if ((c = cin.get()) != ' ')
//cout.put(c);
cout << c;
}
4. Opérations sur les fichiers et flux de fichiers
1. La notion de fichiers
Un fichier fait référence à un ensemble de données stockées sur un support de stockage. Le système d'exploitation extrait les données pertinentes sur le support de stockage dans des fichiers, les nomme avec des identifiants et gère les fichiers par le système de fichiers. Tant que l'utilisateur indique le nom du fichier, le système d'exploitation peut accéder aux informations du fichier par son nom. Selon la représentation des données dans le fichier, les fichiers sont divisés en fichiers ASCII et fichiers binaires. Les fichiers ASCII sont des fichiers texte, chaque octet représentant un caractère. Les fichiers binaires stockent les données et les instructions dans la mémoire du disque en fonction de leur format dans la mémoire.
Les informations sur les caractères sont également stockées sous forme de code ASCII dans la mémoire, de sorte que la forme des caractères dans le fichier de code ASCII est la même que celle du fichier binaire. Pour les données numériques, les deux ne sont pas identiques. Par exemple, un entier décimal 100 000 utilise quatre octets lorsqu'il est représenté en binaire, alors qu'il utilise six octets lorsqu'il est représenté en code ASCII.
2. Classe de flux de fichiers et objet de flux de fichiers
Un flux de fichiers est un flux de données qui utilise des fichiers externes comme objets d'entrée et de sortie. Le flux du fichier de sortie est le flux de données de la mémoire vers le fichier de stockage externe, et le flux du fichier d'entrée est le flux de données du fichier de stockage externe vers la mémoire. Afin de compenser la différence de vitesse entre l'accès à la mémoire et l'accès à la mémoire externe, chaque flux de fichiers dispose d'une mémoire tampon.
Plusieurs classes de fichiers sont définies dans la bibliothèque de classes d'E/S C++, qui sont spécifiquement utilisées pour les opérations d'entrée et de sortie de fichiers.
Sur la figure, nous pouvons voir que C++ dérive trois classes de flux de fichiers à partir des classes de flux d'entrée et de sortie standard.
- La classe ifstream prend en charge les entrées à partir de fichiers disque.
- La classe ofstream prend en charge la sortie vers des fichiers disque.
- La classe fstream prend en charge la sortie et la sortie vers des fichiers disque.
Pour entrer et sortir des fichiers, vous devez définir un objet de classe de flux de fichiers et utiliser l'objet pour appeler les fonctions membres de la classe pour opérer sur le fichier.
3. Ouverture et fermeture de fichiers
- Ouverture d'un fichier disque
Il existe deux manières d'ouvrir un fichier :
(1) Créez un objet de flux de fichiers et utilisez l'objet pour appeler la fonction membre de classe open.
La forme générale d'appel des fonctions membres : file stream object.open (nom du fichier, mode d'entrée et de sortie);
exemple : ofstream outfile ;
outfile.open("f1.txt", ios::out);
(2) Définition du fichier objet stream Lors de la spécification des paramètres,
la forme générale d'appel d'une fonction membre est la suivante : objet de classe flux de fichier (nom de fichier, mode d'entrée et de sortie) ;
exemple : ofstream outfile ("f1.txt", ios::out); - Fermeture du fichier disque
Une fois le fichier utilisé, le fichier doit être fermé, ce qui est implémenté en appelant la fonction membre de fermeture de fichier à l'aide de l'objet flux de fichiers.
Format : File stream object.close();
Fonction : Dissocier l’objet file stream du fichier disque.
4. Fonctionnement sur les fichiers de code ASCII
Les fichiers de code ASCII sont également des fichiers texte et chaque octet du fichier stocke un caractère. Les opérations sur les fichiers de code ASCII incluent l'écriture de caractères dans le fichier et la lecture de caractères dans le fichier.
Il existe deux méthodes pour lire et écrire des fichiers de code ASCII : l'objet de flux de fichiers et les opérateurs d'extraction et d'insertion, et l'utilisation de l'objet de flux de fichiers pour appeler les fonctions membres put, get et getline de la classe.
Exemple : définissez un tableau d'entiers avec dix éléments, saisissez dix entiers à l'aide du clavier, placez-les dans le tableau et utilisez l'opérateur d'insertion pour les écrire dans le fichier f1.txt du répertoire actuel.
#include <iostream>
#include <iomanip>
#include<fstream>
using namespace std;
int main()
{
int a[10];
ofstream outfile("f1.txt");
if (!outfile)
{
cerr << "open error!" << endl;
exit(1);
}
cout << "enter 10 integer numbers:" << endl;
for (int i = 0; i < 10; i++)
{
cin >> a[i];
outfile << a[i] << " ";
}
outfile.close();
return 0;
}
注：程序中用文件流类ofstream，它是在头文件fstream中定义的，用vc6.0时要把这个头文件包含进来。
5. Opération sur les fichiers binaires
Les fichiers binaires sont écrits sur des fichiers disque sous forme de stockage de données en mémoire. Ils sont donc également appelés fichiers image de données en mémoire.
Le fonctionnement des fichiers binaires est similaire au fonctionnement des fichiers texte : définissez d'abord l'objet flux de fichier, puis ouvrez le fichier et fermez le fichier après utilisation. Lors de l'ouverture, vous devez préciser que le fichier est stocké sous forme binaire. Les fichiers binaires peuvent être utilisés comme fichiers d'entrée ou de sortie, ou comme fichiers pouvant être à la fois d'entrée et de sortie. Ceci est différent des fichiers ASCII.
- Utilisez les fonctions membres read et write pour lire et écrire des fichiers respectivement.
Pour lire des fichiers binaires, utilisez la fonction membre read de la classe istream ; pour écrire des fichiers binaires, utilisez la fonction membre write de la classe ostream.
Leurs prototypes de fonctions sont :
istream& read(char * bu, int len);
ostream& write( const char * bu, int len);
Le pointeur de caractère bu pointe vers la position de départ des données à lire ou à écrire dans la mémoire. len est le nombre d'octets de données à lire et à écrire en même temps (longueur des données).
Format d'appel :
flux de fichier d'entrée object.read (pointeur de mémoire, longueur) ;
flux de fichier de sortie object.write (pointeur de mémoire, longueur) ;
Exemple : Écrivez un lot de données dans un fichier disque sous forme binaire, lisez les données du fichier et affichez-les à l'écran.
struct student
{
char name[20];
int num;
int age;
char sex;
};
int main()
{
student stud[3]={
"Li", 1001,18,'f', "Fun",1002,19,'m', "Wang",1004,17,'f'};
ofstream outfile("stud.dat",ios::binary);
if(!outfile) {
cerr<<"open error!"<<endl; abort(); }
outfile.write( (char *)&stud,sizeof(stud));
outfile.close();
return 0;
}
int main()
{
student stud[3]; int i;
ifstream infile("stud.dat", ios::binary);
if (!infile) {
cerr << "open error!" << endl; abort(); }
infile.read((char*)stud, sizeof(stud));
infile.close();
for (i = 0; i < 3; i++)
{
cout << "NO." << i + 1 << endl;
cout << "姓名:" << stud[i].name << endl;
cout << "学号:" << stud[i].num << endl;
cout << "年龄:" << stud[i].age << endl;
cout << "性别:" << stud[i].sex << endl << endl;
}
return 0;
}
- Fonctions membres de la classe Stream liées aux pointeurs de fichiers
Afin de lire de manière aléatoire des données dans un fichier binaire, le fichier disque utilise un pointeur pour représenter l'emplacement actuel auquel accéder. Le pointeur est automatiquement modifié à chaque fois que le fichier est lu ou écrit. Faites en sorte que le pointeur pointe toujours vers l'emplacement actuel auquel accéder. Pour les fichiers binaires, le programme est autorisé à contrôler le mouvement du pointeur pour obtenir un accès aléatoire au fichier. La classe file stream fournit des fonctions membres liées aux pointeurs de fichiers.
La position et le déplacement dans le fichier de paramètres de fonction sont en octets et sont des entiers longs. La position de référence indique quel est le point de départ du mouvement.
La classe ios est définie comme :
ios::beg commence au début du fichier, ce qui est la valeur par défaut.
ios::cur démarre à partir de la position actuelle du pointeur.
ios::end commence à la fin du fichier. - Accédez aléatoirement aux fichiers de données binaires.Utilisez
les fonctions membres de la classe stream pour déplacer le pointeur de fichier afin d'obtenir un accès aléatoire aux données dans n'importe quel octet du fichier.
Exemple : Il y a cinq données d'élèves et les exigences sont les suivantes :
1) Écrivez-les dans un fichier disque
2) Lisez les données du 1er, du 3e et du 5e élève à partir du fichier disque et affichez-les
3) Modifiez les données du 3e élève et enregistrez-les. à l'emplacement d'origine
4) Lisez les données modifiées des 5 étudiants à partir du fichier disque et affichez-les
struct student
{
int num; char name[20]; float score;
};
int main()
{
int i;
student stud[5] = {
1001,"Li",85,1002,"Fun",97.5,1004,"Wang",54,1006,"Tan",76.5,1010,"ling",96 };
fstream iofile("stud.dat", ios::in | ios::out | ios::binary);
if (!iofile)
{
cerr << "open error!" << endl; abort();
}
for (i = 0; i < 5; i++)
iofile.write((char *)&stud[i], sizeof(stud[i]));
student stud1[5];
for (i = 0; i < 5; i = i + 2)
{
iofile.seekg(i * sizeof(stud[i]), ios::beg);
iofile.read((char *)&stud1[i / 2], sizeof(stud1[i]));
cout << stud1[i / 2].num << " " << stud1[i / 2].name << " "<< stud1[i / 2].score << endl;
}
cout << endl;
stud[2].num = 1012;
strcpy(stud[2].name, "Wu");
stud[2].score = 60;
iofile.seekp(2 * sizeof(stud[0]), ios::beg);
iofile.write((char *)&stud[2], sizeof(stud[2]));
iofile.seekg(0, ios::beg);
for (i = 0; i < 5; i++)
{
iofile.read((char *)&stud[i], sizeof(stud[i]));
cout << stud[i].num << " " << stud[i].name << " "<< stud[i].score << endl;
}
iofile.close();
return 0;
}
5. Flux de chaînes
Le flux de chaînes utilise un tableau de caractères (chaîne) défini par l'utilisateur en mémoire comme objet d'entrée et de sortie, c'est-à-dire écrire des données dans la matrice mémoire ou lire des données à partir du tableau de caractères mémoire.
Les flux de chaînes ont également besoin de tampons. Lors de la lecture ou de l'écriture, les données dans le tampon du flux continuent d'augmenter. Lorsque le tampon est plein ou qu'un caractère de nouvelle ligne est rencontré, les données du tampon sont écrites ensemble dans un tableau de caractères ou affectées à un caractère spécifié. variable.
Le prototype constructeur de la classe ostrstream pour créer un objet de flux de chaîne est :
ostrstream::ostrstream(char *bu, int n, int mode =ios::out);
Le prototype constructeur de la classe istrstream pour créer un objet flux de chaîne de lecture est :
istrstream::istrstream( char *bu, int n);
istrstream::istrstream( char *bu);
Le prototype constructeur de la classe strstream pour créer un objet flux de chaîne en lecture et en écriture est :
strstream::strstream(char *bu, int n, int mode);
Exemple : Pour stocker 10 entiers dans un tableau de caractères c, avec des espaces comme délimiteurs, il est nécessaire de les placer dans le tableau d'entiers par ordre croissant, puis de les écrire dans le tableau de caractères d'origine.
#include <iostream>
#include <iomanip>
#include<fstream>
#include<strstream>
using namespace std;
int main()
{
char c[50] = "12 34 65 -23 -32 33 61 99 321 32";
int a[10], i, j, t;
cout << "array c:" << c << endl;
istrstream strin(c, sizeof(c));
for (i = 0; i < 10; i++)
strin >> a[i];
cout << "array a:";
for (i = 0; i < 10; i++)
cout << a[i] << " ";
cout << endl;
for (i = 0; i < 9; i++)
for (j = 0; j < 9 - i; j++)
if (a[j] > a[j + 1])
{
t = a[j]; a[j] = a[j + 1]; a[j + 1] = t;
}
ostrstream strout(c, sizeof(c));
for (i = 0; i < 10; i++)
strout << a[i] << " ";
strout << ends;
cout << "array c:" << c << endl;
return 0;
}
