文件流fstream从txt文件中读取多行与向txt文件存储多行

https://blog.youkuaiyun.com/ycwwl1993/article/details/89534280本文链
一、头文件与类型

文件流类型包含在 fstream 头文件中，包括以下类型：
    ifstream/wifstream 从文件读取数据
    ofstream/wofstream 向文件写入数据
    fstream/wfstream 读写文件
二、IO库类型间的关系
  概念上，设备类型与字符大小都不影响我们要执行的IO操作。我们可以用 >> 读取数据，而不用管是从那里读取，可以是控制台窗口，也可以是磁盘文件（txt文件等），还可以是 string 等。同样，我们也不用管读取的字符的大小（虽然 >> 读取数据都可以进行，但我们应该选择一个适当的存储对象）。
  标准库使得我们能忽略这些不同类型的流之间的差异，这是通过继承机制实现的（我们先不管继承机制如何工作）。我们可以声明一个特定的类继承自另一个类。我们通常可以将一个派生类（继承类）对象当作其基类（所继承的类）对象来使用。
  类型 ifstream 继承自 istream (string 流类型 istringstream 也继承自 istream），所以，我们可以像使用 istream 对象一样来使用 ifstream 对象（不同的在于读取数据的方向不同，istream 从流读取数据，ifstream 从文件读取数据）。例如：我们可以向使用 cin 一样使用一个 ifstream 对象，也可以对该对象调用 getline 函数。类似的，类型 ofstream 继承自 ostream，我们可以像使用 cout 一样，使用 ofstream 对象。
三、从文件中读取数据
  首相我们在源文件的根目录下建立一个 txt 文件，或者建立在其他目录下，博主建立在了桌面，并输入以下内容
————————————————
版权声明：本文为优快云博主「夜茶微微凉」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/ycwwl1993/article/details/89534280

 

 

接下来我们就可以将这个文件与一个 ifstream 对象绑定，并在控制台窗口输出其中内容：

#include<iostream>
#include<string>
#include<fstream>
using std::ifstream;
using std::string;
using std::cout;
using std::endl;
int main(){
    string str;
    ifstream ifs("地址\\写入.txt");//地址是文件存储地址，与源文件同一目录下，可以省略
    ifs >> str;
    cout << str << endl;
    ifs >> str;
    cout << str << endl;
    ifs >> str;
    cout << str << endl;
    ifs.close();
    return 0;
}
 

执行程序结果：

第一行
123
第二行
从执行结果看，当 >> 遇到空格或换行时，就会终止，并在下次进行 >> 时，从空格或换行后继续进行。
  我们可以利用 getline 一行一行的读取：

#include<iostream>
#include<fstream>
#include<string>
using std::cout;
using std::ifstream;
using std::ofstream;
using std::endl;
using std::string;
int main(){
    string str;
    ifstream ifs("地址\\写入.txt");
    for (; ifs.good();) {
    getline(ifs, str);
    cout << str << endl;
    }
   ifs.close();
   return 0;
}
 

第一行 123
第二行 234
第三行 456
第四行 567
第五行 678
第六行 789
第七行 890
综上，ifs 与 文件绑定，与 cin 与控制台窗口绑定一样，会将整个文档内容作为输入内容，并利用 >> 或 getline 逐个或逐行输入。
四、向txt文件存储多行
  我们将上面文档中的内容存储在另一个文件中。回忆 cout 的用法，如果换行，我们可以利用 endl 控制换行，但是在向文档中输入时，不能用 endl 控制换行，我们可以利用 “\n” 控制换行（windows系统下，需要输入"\r\n"），代码如下：
#include<iostream>
#include<fstream>
#include<string>
using std::cout;
using std::ifstream;
using std::ofstream;
using std::endl;
using std::string;
int main(){
    string str;
    ifstream ifs("地址\\写入.txt");
    ofstream ofs("地址\\输出.txt");
    for (; ifs.good();) {
    getline(ifs, str);
    ofs<<str<<"\r\n";
    }
   ifs.close();
   ofs.close();
   return 0;
}
最后在目标文件中，会存有输出内容，但最后会多出一个空行，因为每次输出都会输出一个换行符，最后一次输出换行符是多余的。
  另外，如果我们输出目标文件不存在，程序会为我们在我们指定的目录下，创建一个目标文件，并存储输出内容。如果未指定地址，会在源文件的根目录下创建目标文件。

 

http://c.biancheng.net/view/302.html

C++二进制文件的读取和写入（精华版）

我们先来说一下为什么要使用二进制文件，它比文本文件有哪些好处。

用文本方式存储信息不但浪费空间，而且不便于检索。例如，一个学籍管理程序需要记录所有学生的学号、姓名、年龄信息，并且能够按照姓名查找学生的信息。程序中可以用一个类来表示学生：

1. class CStudent
2. {
3. char szName[20]; //假设学生姓名不超过19个字符，以 '\0' 结尾
4. char szId[l0]; //假设学号为9位，以 '\0' 结尾
5. int age; //年龄
6. };

如果用文本文件存储学生的信息，文件可能是如下样子：
Micheal Jackson 110923412 17
Tom Hanks 110923413 18

这种存储方式不但浪费空间，而且查找效率低下。因为每个学生的信息所占用的字节数不同，所以即使文件中的学生信息是按姓名排好序的，要用程序根据名字进行查找仍然没有什么好办法，只能在文件中从头到尾搜索。

如果把全部的学生信息都读入内存并排序后再查找，当然速度会很快，但如果学生数巨大，则把所有学生信息都读人内存可能是不现实的。

可以用二进制的方式来存储学生信息，即把 CStudent 对象直接写入文件。在该文件中，每个学生的信息都占用 sizeof(CStudent) 个字节。对象写入文件后一般称作“记录”。本例中，每个学生都对应于一条记录。该学生记录文件可以按姓名排序，则使用折半查找的效率会很高。

读写二进制文件不能使用前面提到的类似于 cin、cout 从流中读写数据的方法。这时可以调用 ifstream 类和 fstream 类的 read 成员函数从文件中读取数据，调用 ofstream 和 fstream 的 write 成员函数向文件中写入数据。

用 ostream::write 成员函数写文件

ofstream 和 fstream 的 write 成员函数实际上继承自 ostream 类，原型如下：

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

该成员函数将内存中 buffer 所指向的 count 个字节的内容写入文件，返回值是对函数所作用的对象的引用，如 obj.write(...) 的返回值就是对 obj 的引用。

write 成员函数向文件中写入若干字节，可是调用 write 函数时并没有指定这若干字节要写入文件中的什么位置。那么，write 函数在执行过程中到底把这若干字节写到哪里呢？答案是从文件写指针指向的位置开始写入。

文件写指针是 ofstream 或 fstream 对象内部维护的一个变量。文件刚打开时，文件写指针指向文件的开头（如果以 ios::app 方式打开，则指向文件末尾），用 write 函数写入 n 个字节，写指针指向的位置就向后移动 n 个字节。

下面的程序从键盘输入几名学生的姓名和年龄（输入时，在单独的一行中按 Ctrl+Z 键再按回车键以结束输入。假设学生姓名中都没有空格），并以二进制文件形式存储，成为一个学生记录文件 students.dat。

例子，用二进制文件保存学生记录：

1. #include <iostream>
2. #include <fstream>
3. using namespace std;
4. class CStudent
5. {
6. public:
7. char szName[20];
8. int age;
9. };
10. int main()
11. {
12. CStudent s;
13. ofstream outFile("students.dat", ios::out | ios::binary);
14. while (cin >> s.szName >> s.age)
15. outFile.write((char*)&s, sizeof(s));
16. outFile.close();
17. return 0;
18. }

输入：
Tom 60↙
Jack 80↙
Jane 40↙
^Z↙

则形成的 students.dat 为 72 字节，用“记事本”程序打开呈现乱码：

Tom烫烫烫烫烫烫烫烫 Jack烫烫烫烫烫烫烫？ Jane烫烫烫烫烫烫烫？

第 13 行指定文件的打开模式是 ios::out|ios::binary，即以二进制写模式打开。在 Windows平台中，用二进制模式打开是必要的，否则可能出错，原因会在《文件的文本打开方式和二进制打开方式的区别》一节中介绍。

第 15 行将 s 对象写入文件。s 的地址就是要写入文件的内存缓冲区的地址。但是 &s 不是 char * 类型，因此要进行强制类型转换。

第 16 行，文件使用完毕一定要关闭，否则程序结束后文件的内容可能不完整。

用 istream::read 成员函数读文件

ifstream 和 fstream 的 read 成员函数实际上继承自 istream 类，原型如下：

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

该成员函数从文件中读取 count 个字节的内容，存放到 buffer 所指向的内存缓冲区中，返回值是对函数所作用的对象的引用。

如果想知道一共成功读取了多少个字节（读到文件尾时，未必能读取 count 个字节），可以在 read 函数执行后立即调用文件流对象的 gcount 成员函数，其返回值就是最近一次 read 函数执行时成功读取的字节数。gcount 是 istream 类的成员函数，原型如下：

int gcount();

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

下面的程序将前面创建的学生记录文件 students.dat 的内容读出并显示。

1. #include <iostream>
2. #include <fstream>
3. using namespace std;
4. class CStudent
5. {
6. public:
7. char szName[20];
8. int age;
9. };
10. int main()
11. {
12. CStudent s;
13. ifstream inFile("students.dat",ios::in|ios::binary); //二进制读方式打开
14. if(!inFile) {
15. cout << "error" <<endl;
16. return 0;
17. }
18. while(inFile.read((char *)&s, sizeof(s))) { //一直读到文件结束
19. int readedBytes = inFile.gcount(); //看刚才读了多少字节
20. cout << s.szName << " " << s.age << endl;
21. }
22. inFile.close();
23. return 0;
24. }

程序的输出结果是：
Tom 60
Jack 80
Jane 40

第 18 行，判断文件是否已经读完的方法和 while(cin>>n) 类似，归根到底都是因为 istream 类重载了 bool 强制类型转换运算符。

第 19 行只是演示 gcount 函数的用法，删除该行对程序运行结果没有影响。

思考题：关于 students.dat 的两个程序中，如果 CStudent 类的 szName 的定义不是“char szName[20] ”而是“string szName”，是否可以？为什么？

用文件流类的 put 和 get 成员函数读写文件

可以用 ifstream 和 fstream 类的 get 成员函数（继承自 istream 类）从文件中一次读取一个字节，也可以用 ofstream 和 fstream 类的 put 成员函数（继承自 ostream 类） 向文件中一次写入一个字节。

例题：编写一个 mycopy 程序，实现文件复制的功能。用法是在“命令提示符”窗口输入：

mycopy 源文件名 目标文件名

就能将源文件复制到目标文件。例如：

mycopy src.dat dest.dat

即将 src.dat 复制到 dest.dat。如果 dest.dat 原本就存在，则原来的文件会被覆盖。

解题的基本思路是每次从源文件读取一个字节，然后写入目标文件。程序如下：

1. #include <iostream>
2. #include <fstream>
3. using namespace std;
4. int main(int argc, char* argv[])
5. {
6. if (argc != 3) {
7. cout << "File name missing!" << endl;
8. return 0;
9. }
10. ifstream inFile(argv[l], ios::binary | ios::in); //以二进制读模式打开文件
11. if (!inFile) {
12. cout << "Source file open error." << endl;
13. return 0;
14. }
15. ofstream outFile(argv[2], ios::binary | ios::out); //以二进制写模式打开文件
16. if (!outFile) {
17. cout << "New file open error." << endl;
18. inFile.close(); //打开的文件一定要关闭
19. return 0;
20. }
21. char c;
22. while (inFile.get(c)) //每次读取一个字符
23. outFile.put(c); //每次写入一个字符
24. outFile.close();
25. inFile.close();
26. return 0;
27. }

文件存放于磁盘中，磁盘的访问速度远远低于内存。如果每次读一个字节或写一个字节都要访问磁盘，那么文件的读写速度就会慢得不可忍受。因此，操作系统在接收到读文件的请求时，哪怕只要读一个字节，也会把一片数据（通常至少是 512 个字节，因为磁盘的一个扇区是 512 B）都读取到一个操作系统自行管理的内存缓冲区中，当要读下一个字节时，就不需要访问磁盘，直接从该缓冲区中读取就可以了。

操作系统在接收到写文件的请求时，也是先把要写入的数据在一个内存缓冲区中保存起来，等缓冲区满后，再将缓冲区的内容全部写入磁盘。关闭文件的操作就能确保内存缓冲区中的数据被写入磁盘。

尽管如此，要连续读写文件时，像 mycopy 程序那样一个字节一个字节地读写，还是不如一次读写一片内存区域快。每次读写的字节数最好是 512 的整数倍。