Comment lire et écrire des fichiers en C++

Méthodes de lecture et d'écriture de fichiers C++ : 1. Utilisez les opérateurs ">>" et "<<" 2. Utilisez "istream::read()" et " ostream::write ; ()" ; 3. Utilisez les méthodes membres "istream::get()" et "ostream::put()".

L'environnement d'exploitation de ce tutoriel : système Windows 7, version C++17, ordinateur Dell G3.

Méthode 1 : C++ >> et <

La classe fstream ou ifstream est responsable de implémentant le fichier. En lecture, ils surchargent tous l'opérateur de flux de sortie >> en interne ; de même, les classes fstream et ofstream sont responsables de l'écriture des fichiers, et elles surchargent également l'opérateur de flux de sortie <code><< en interne.

Ainsi, lorsque l'objet de classe fstream ou ifstream ouvre le fichier (généralement en utilisant ios::in comme mode d'ouverture), vous pouvez directement utiliser l'opérateur de flux d'entrée >> file ( ou string ); lorsqu'un objet de classe fstream ou ofstream ouvre un fichier (généralement en utilisant ios::out comme mode d'ouverture), vous pouvez directement écrire des caractères (ou des chaînes) dans le fichier à l'aide de << opérateur de flux de sortie.

#include <iostream>
#include <fstream>
using namespace std;
int main()
{
    int x,sum=0;
    ifstream srcFile("in.txt", ios::in); //以文本模式打开in.txt备读
    if (!srcFile) { //打开失败
        cout << "error opening source file." << endl;
        return 0;
    }
    ofstream destFile("out.txt", ios::out); //以文本模式打开out.txt备写
    if (!destFile) {
        srcFile.close(); //程序结束前不能忘记关闭以前打开过的文件
        cout << "error opening destination file." << endl;
        return 0;
    }
    //可以像用cin那样用ifstream对象
    while (srcFile >> x) {
        sum += x;
        //可以像 cout 那样使用 ofstream 对象
        destFile << x << " ";
    }
    cout << "sum：" << sum << endl;
    destFile.close();
    srcFile.close();
    return 0;
}

Avant d'exécuter ce programme, vous devez créer manuellement un fichier in.txt dans le même répertoire que le fichier source du programme. Supposons que la chaîne stockée en interne soit :

10 20 30 40 50

Après la création. , exécuter Le résultat de l'exécution du programme est :

sum：150

En même temps, un fichier out.txt sera généré dans le même répertoire que le fichier in.txt. Les caractères stockés à l'intérieur sont exactement les mêmes que ceux. le fichier in.txt. Les lecteurs peuvent ouvrir le fichier eux-mêmes.

Ce n'est pas difficile à comprendre en analysant les résultats d'exécution du programme. Pour la chaîne "10 20 30 40 50" dans le fichier in.txt, l'objet srcFile convertira séquentiellement "10", "20". ", "30", "40" et "50" sont lus, analysés en entiers de type int 10, 20, 30, 40, 50 et attribués à x, et l'opération d'addition avec somme est terminée en même temps.

De même, pour chaque entier x lu et analysé à partir du fichier in.txt, l'objet destFile l'analysera dans la chaîne correspondante sans modification (comme l'entier 10 analysé dans une chaîne " 10 "), puis écrivez-le dans le fichier out.txt avec le caractère espace " ".

Méthode 2 : C++ read() et write() pour lire et écrire des fichiers binaires

C++ ostream::write( ) méthode Écrire des fichiers

La méthode membre write() de ofstream et fstream est en fait héritée de la classe ostream. Sa fonction est d'écrire le nombre d'octets pointés par le tampon dans la mémoire dans le fichier. . Le format de base est le suivant :

ostream & write(char* buffer, int count);

Parmi eux, le tampon est utilisé pour spécifier la position de départ des données binaires à écrire dans le fichier ; le nombre d'octets à écrire est utilisé ;

C'est-à-dire que cette méthode peut être appelée par l'objet cout de la classe ostream, et est souvent utilisée pour afficher des chaînes à l'écran. Dans le même temps, il peut également être appelé par des objets ofstream ou fstream pour écrire un nombre spécifié de données binaires dans un fichier.

En même temps, cette méthode renverra un objet sous forme de référence qui agit sur la fonction. Par exemple, la valeur de retour de la méthode obj.write() est une référence à l'objet obj.

Une chose à noter est que la méthode membre write() écrit un certain nombre d'octets dans le fichier, mais l'emplacement spécifique où ces octets sont écrits dans le fichier n'est pas spécifié lors de l'appel de la fonction write(). En fait, la méthode write() écrit les données binaires à partir de l'emplacement pointé par le pointeur d'écriture de fichier. Le soi-disant pointeur d'écriture de fichier est une variable maintenue en interne par l'objet ofstream ou fstream. Lorsque le fichier est ouvert pour la première fois, le pointeur d'écriture de fichier pointe vers le début du fichier (s'il est ouvert en mode ios :: app). pointe vers la fin du fichier). Utilisez la méthode write() pour écrire n octets et la position pointée par le pointeur d'écriture recule de n octets.

Le programme suivant montre comment écrire les informations sur les étudiants dans un fichier sous forme binaire :

#include <iostream>
#include <fstream>
using namespace std;
class CStudent
{
public:
    char szName[20];
    int age;
};
int main()
{
    CStudent s;
    ofstream outFile("students.dat", ios::out | ios::binary);
    while (cin >> s.szName >> s.age)
        outFile.write((char*)&s, sizeof(s));
    outFile.close();
    return 0;
}

Entrée :

Tom 60↙
Jack 80↙
Jane 40↙
^Z↙

où, ↙ représente le caractère de nouvelle ligne de sortie, ^Z signifie saisir la combinaison de touches Ctrl+Z pour terminer la saisie.

Après l'exécution du programme, un fichier Students.dat sera automatiquement généré, qui contient 72 octets de données. Si vous ouvrez ce fichier avec "Notepad", vous pouvez voir les caractères tronqués suivants :

Tom 烫烫烫烫烫烫烫烫<   Jack 烫烫烫烫烫烫烫蘌   Jane 烫烫烫烫烫烫烫?

.

Il convient de mentionner que le mode d'ouverture du fichier spécifié à la ligne 13 du programme est ios::out | ios::binary, c'est-à-dire qu'il est ouvert en mode d'écriture binaire. Sur la plateforme Windows, il est très nécessaire d'ouvrir le fichier en mode binaire, sinon une erreur pourrait survenir.

De plus, la ligne 15 écrit l'objet s dans le fichier. L'adresse de s est l'adresse du tampon mémoire à écrire dans le fichier, mais &s n'est pas de type char *, donc une conversion de type forcée est requise, ligne 16, le fichier doit être fermé après utilisation, sinon le contenu du Le fichier peut être incomplet une fois le programme terminé.

La méthode C++ istream::read() lit les fichiers

La méthode read() de ifstream et fstream hérite en fait de la classe istream, et sa fonction est exactement la identique à write() La méthode opposée consiste à lire le nombre d'octets de données du fichier. Le format de syntaxe de cette méthode est le suivant :

istream & read(char* buffer, int count);

其中，buffer 用于指定读取字节的起始位置，count 指定读取字节的个数。同样，该方法也会返回一个调用该方法的对象的引用。

和 write() 方法类似，read() 方法从文件读指针指向的位置开始读取若干字节。所谓文件读指针，可以理解为是 ifstream 或 fstream 对象内部维护的一个变量。文件刚打开时，文件读指针指向文件的开头（如果以 ios::app 方式打开，则指向文件末尾），用 read() 方法读取 n 个字节，读指针指向的位置就向后移动 n 个字节。因此，打开一个文件后连续调用 read() 方法，就能将整个文件的内容读取出来。

通过执行 write() 方法的示例程序，我们将 3 个学生的信息存储到了 students.dat 文件中，下面程序演示了如何使用 read() 方法将它们读取出来：

#include <iostream>
#include <fstream>
using namespace std;
class CStudent
{
public:
    char szName[20];
    int age;
};
int main()
{
    CStudent s;       
    ifstream inFile("students.dat",ios::in|ios::binary); //二进制读方式打开
    if(!inFile) {
        cout << "error" <<endl;
        return 0;
    }
    while(inFile.read((char *)&s, sizeof(s))) { //一直读到文件结束
        cout << s.szName << " " << s.age << endl;   
    }
    inFile.close();
    return 0;
}

程序的输出结果是：

Tom 60
Jack 80
Jane 40

注意，程序中第 18 行直接将 read() 方法作为 while 循环的判断条件，这意味着，read() 方法会一直读取到文件的末尾，将所有字节全部读取完毕，while 循环才会终止。

方法3：C++ get()和put()读写文件

在某些特殊的场景中，我们可能需要逐个读取文件中存储的字符，或者逐个将字符存储到文件中。这种情况下，就可以调用 get() 和 put() 成员方法实现。

C++ ostream::put()成员方法

我们知道，fstream 和 ofstream 类继承自 ostream 类，因此 fstream 和 ofstream 类对象都可以调用 put() 方法。

当 fstream 和 ofstream 文件流对象调用 put() 方法时，该方法的功能就变成了向指定文件中写入单个字符。put() 方法的语法格式如下：

ostream& put (char c);

其中，c 用于指定要写入文件的字符。该方法会返回一个调用该方法的对象的引用形式。例如，obj.put() 方法会返回 obj 这个对象的引用。

举个例子：

#include <iostream>
#include <fstream>
using namespace std;
int main()
{
    char c;
    //以二进制形式打开文件
    ofstream outFile("out.txt", ios::out | ios::binary);
    if (!outFile) {
        cout << "error" << endl;
        return 0;
    }
    while (cin >> c) {
        //将字符 c 写入 out.txt 文件
        outFile.put(c);
    }
    outFile.close();
    return 0;
}

执行程序，输入：

https://www.php.cn/↙
^Z↙

其中，↙表示输入换行符；^Z是 Ctrl+Z 的组合键，表示输入结束。

由此，程序中通过执行 while 循环，会将 "https://www.php.cn/" 字符串的字符逐个复制给变量 c，并逐个写入到 out.txt 文件。

注意，由于文件存放在硬盘中，硬盘的访问速度远远低于内存。如果每次写一个字节都要访问硬盘，那么文件的读写速度就会慢得不可忍受。因此，操作系统在接收到 put() 方法写文件的请求时，会先将指定字符存储在一块指定的内存空间中（称为文件流输出缓冲区），等刷新该缓冲区（缓冲区满、关闭文件、手动调用 flush() 方法等，都会导致缓冲区刷新）时，才会将缓冲区中存储的所有字符“一股脑儿”全写入文件。

C++ istream::get()成员方法

和 put() 成员方法的功能相对的是 get() 方法，其定义在 istream 类中，借助 cin.get() 可以读取用户输入的字符。在此基础上，fstream 和 ifstream 类继承自 istream 类，因此 fstream 和 ifstream 类的对象也能调用 get() 方法。

当 fstream 和 ifstream 文件流对象调用 get() 方法时，其功能就变成了从指定文件中读取单个字符（还可以读取指定长度的字符串）。值得一提的是，get() 方法的语法格式有很多（请猛击这里了解详情），这里仅介绍最常用的 2 种：

int get();
istream& get (char& c);

其中，第一种语法格式的返回值就是读取到的字符，只不过返回的是它的 ASCII 码，如果碰到输入的末尾，则返回值为 EOF。第二种语法格式需要传递一个字符变量，get() 方法会自行将读取到的字符赋值给这个变量。

本节前面在讲解 put() 方法时，生成了一个 out.txt 文件，下面的样例演示了如何通过 get() 方法逐个读取 out.txt 文件中的字符：

#include <iostream>
#include <fstream>
using namespace std;
int main()
{
    char c;
    //以二进制形式打开文件
    ifstream inFile("out.txt", ios::out | ios::binary);
    if (!inFile) {
        cout << "error" << endl;
        return 0;
    }
    while ( (c=inFile.get())&&c!=EOF )   //或者 while(inFile.get(c))，对应第二种语法格式
    {
        cout << c ;
    }
    inFile.close();
    return 0;
}

程序执行结果为：

https://www.php.cn/

注意，和 put() 方法一样，操作系统在接收到 get() 方法的请求后，哪怕只读取一个字符，也会一次性从文件中将很多数据（通常至少是 512 个字节，因为硬盘的一个扇区是 512 B）读到一块内存空间中（可称为文件流输入缓冲区），这样当读取下一个字符时，就不需要再访问硬盘中的文件，直接从该缓冲区中读取即可。

更多编程相关知识，请访问：编程视频！！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!