【C++】一文掌握C++中的IO流

---

1 C语言中的输入与输出

C语言中我们用到的最频繁的输入输出方式就是scanf ()与printf()。

1. scanf(): 从标准输入设备(键盘)读取数据，并将值存放在变量中。
2. printf(): 将指定的文字/字符串输出到标准输出设备(屏幕)。注意宽度输出和精度输出控制。

C语言借助了相应的缓冲区来进行输入与输出。如下图所示：

对输入输出缓冲区的理解：
1.可以屏蔽掉低级I/O的实现，低级I/O的实现依赖操作系统本身内核的实现，所以如果能够屏蔽这部分的差异，可以很容易写出可移植的程序。
2.可以使用这部分的内容实现“行”读取的行为，对于计算机而言是没有“行”这个概念，有了这部分，就可以定义“行”的概念，然后解析缓冲区的内容，返回一个“行”。

C语言提供了多样化的接口，对于文件输入输出提供了fprintf和fscanf。对于字符串的输入输出提供了sprintf sscanf 等接口：

2 流是什么

流:即是流动的意思，是物质从一处向另一处流动的过程，是对一种有序连续且具有方向性的数据（ 其单位可以是bit byte packet ）的抽象描述。

C++流是指信息从外部输入设备（如键盘）向计算机内部（如内存）输入和从内存向外部输出设备（显示器）输出的过程。这种输入输出的过程被形象的比喻为流。

它的特性是：有序连续、具有方向性。

为了实现这种流动，C++定义了I/O标准类库，这些每个类都称为流/流类，用以完成某方面的功能。

3 C++中的IO流

3.1 IO流

我们来看一下C++中的IO流对象体系：

ios_base类是基类，ios类继承了ios_base。通过Ios又分别设置了两个子类istream 和ostream 。这两个类分别都有一个实例对象cin和cout!此外ostream还要标准错误cout和日志输出clog。除了标准IO外,istream 和ostream还有子类：文件流和string流，来提供特殊的使用！

C++标准库提供了4个全局流对象cin、cout、cerr、clog，使用cout进行标准输出，即数据从内存流向控制台(显示器)。使用cin进行标准输入即数据通过键盘输入到程序中，同时C++标准库还提供了cerr用来进行标准错误的输出，以及clog进行日志的输出，从上图可以看出:cout、cerr、clog是ostream类的三个不同的对象，因此这三个对象现在基本没有区别，只是应用场景不同!

再来看operator bool , 这个保证了流输入输出可以转换为bool进行一个判断。在输出输入出错时可以进行一个判断。而operator bool 会去检查四个标志值，按照对应映射返回true或false:

1. goodbit : 表示一切正常！
2. eofbit:读取到结束，会设置这个比特位！
3. failbit：发生一些基本的逻辑错误，会设置这个比特位！
4. badbit:发生不可修复的错误，会设置这个比特位！一般不会遇到种错误
   
   我们来看一下这四个标志：
   
   可以看到，在输入到x的时候，循环退出了，这时可以看到fail被设置了，也就是出现了逻辑错误，因为一个字符不能被int读取。出错之后，可以通过clear接口进行清空，然后在通过get将x读取走， 这样就可以恢复正常了！当然为了保证防止输入了一个字符串，就需要通过不断的进行判断，保证字符都被读走！

3.2 输出格式的设置

上面提及了：get() clear() good()...接口，下面我们来认识一下关于输出格式的接口：

1. width()：这个接口可以获取或设置字符宽度

   • 通过streamsize width (streamsize wide);可以设置下一次输出的字符宽度，也是下次最少输出多少个字符。
   • 可以通过streamsize width() const;获取当前的字符宽度！
     

2. precision:这个接口可以获取或设置浮点精度

   • 通过streamsize precision() const;可以设置下一次输出的浮点精度。
   • 可以通过streamsize precision (streamsize prec);获取当前的浮点精度！
     

3. flags可以通过设置和获取对应标记位，来控制输出格式！可以通过这个接口来控制输出2进制，8进制，16进制，左右对齐，显式数字格式前缀，显式正负号等功能!十分强大！

C++风格的输出是比较繁琐的，我们遇到复杂的输出时，可以使用C风格的输出格式，更加简约，代码可读性也更高！

3.3 C++IO的性能

C++为了兼容C语言，会做出一些妥协优化。C语言的缓冲区只有遇到刷新标志时才会进行刷新，而如果printf缓冲区还没有刷新，我们使用cout会出现什么情况？会先把printf缓冲区刷新出来，再打印cout输出的内容，所以cout之前会先对缓冲区进行检查！所以C++风格IO需要和C风格IO进行缓冲区同步！

并且iostream库中的缓冲区通常是动态分配的，而stdio库中的缓冲区通常是静态分配的。动态分配和释放内存比静态分配内存要慢。

在上面的输出格式中我们看到iostream库支持丰富的格式化选项，C++风格IO需要再运行时进行解析处理，但是C风格IO在编译时就已经确认好输出格式了，这减少了运行时的开销。

对于有大量IO的场景，C++的IO效率会比C风格IO慢，可以使用下面三行代码来进行优化：

	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
1
2
3

1. ios_base::sync_with_stdio(false);
   这行代码的作用是取消 C++ 的 iostream 库与 C 的 stdio 库的同步。通过将 sync_with_stdio 设置为 false，可以解除这种同步，从而提高 I/O 的性能。但是，这样做之后，就不能在同一个程序中混合使用 iostream 和 stdio 函数了，因为它们不再保持同步。
2. cin.tie(nullptr);
   在默认情况下，cin 和 cout 是绑定在一起的，这意味着每次读取 cin 或写入 cout 后，都会立即刷新 cout 的缓冲区。这确保了输入输出操作的顺序性，但可能会导致性能下降。通过将 cin 的绑定解除，可以防止在每次读取输入时自动刷新输出缓冲区，从而提高性能。
3. cout.tie(nullptr);
   类似于对 cin 的操作，这行代码将 cout 的绑定解除。默认情况下，cout 与 cin 绑定，当 cin 被读取时，cout 的缓冲区会被刷新。将 cout 的.tie()设置为 nullptr，可以防止 cout 在 cin 被读取时自动刷新，从而提高性能。

3.4 文件流的操作

对于文件的读取写入，可以使用ifstream和ofstream,或者直接使用fsteam(继承了ifstream和ofstream)。

open：打开文件，可以设置对应的打开方式和C语言很类似。

打开文件之后就要进行写入或者读取了：

1. 写入操作可以使用<<进行流写入，也可以通过write写入一个缓冲区字符串。
2. 读取操作可以通过>>来一个一个字符读取，也可以通过read直接读取到缓冲区中。

int main()
{
	//写入
	ofstream ofs( "file.txt" , std::ios_base::out | std::ios_base::trunc);
	char buffer1[128];
	int cnt = 0;
	while (cnt < 100)
	{
		snprintf(buffer1, 128, "cnt: %d \n", cnt);
		ofs.write(buffer1, strlen(buffer1));
		cnt++;
	}
	
	//关闭文件，不在进行写入
	ofs.close();
	//读取
	ifstream ifs("file.txt", ifstream::in);
	char ch = ifs.get();
	//读取到有效字符就进行打印
	while (ifs.good())
	{
		cout << ch;
		ch = ifs.get();
	}
	cout << endl;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

运行一下：

很顺利的就进行写入和读取！

对于一些特殊的文件，比如音频和图片，就需要使用二进制读取和写入。如果不使用，就会可能会错误识别成无效字符直接就返回了！我们可以来尝试一下二进制读取图片，然后在写入到新的图片中，我们可以来试试可不可以进行成功拷贝：

#include<iostream>
#include<fstream>

using namespace std;

int main()
{
	//读取的图片
	ifstream ifs("图片.png", ifstream::in | ifstream::binary);
	//写入的图片
	ofstream ofs("copy.png", ofstream::out | ofstream::binary);
	
	int n = 0;
	char ch = ifs.get();
	while (ifs.good())
	{
		++n;
		ofs << ch;
		ch = ifs.get();
	}
	cout << n << endl;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

我们来看奥：

可以看到二进制拷贝的一模一样奥！图片可以这样通过二进制拷贝，其他任何文件都可以通过二进制进行拷贝，毕竟万物皆为二进制嘛！

3.5 string类的IO

万物皆为二进制，但是如果两个文件/变量类型不一致时，进行读取写入肯定是会出错的！但是string进行二进制读写时就会崩溃！

因为string本质上是一个结构体，在内存中时以结构体储存的，而内部的字符串是一个指针，指向一个堆空间。如果将string以二进制写入，其实写入的是一个指针，等将其读取出来时，就会这个新指针指向原来的堆空间！这不就坏事了，两个string怎么能拥有同一片堆空间呢！

并且string写入并不会将字符串内容进行写入，只会写入指针！所以如果需要进行类对象的二进制读写时，在类内部就不要使用string,统一使用C风格的字符串！

如果进行文本读写，直接使用流插入，流读取很方便！这样就避免读写出内存中的那些数据！

C++中针对string提供了专门的IO流，针对string的读写，我们可以使用这个IO流。通过这个类，我们可以快速的对数据进行序列化和反序列化：

truct ChatInfo
{
	string _name; // 名字
	int _id; // id
	string _msg; // 聊天信息
};
int main()
{
	// 结构信息序列化为字符串
	ChatInfo winfo = { "张三", 135246, "晚上一起看电影吧"};
	ostringstream oss;
	oss << winfo._name << " " << winfo._id << " "<< winfo._msg;
	string str = oss.str();
	cout << str << endl << endl;
	// 我们通过网络这个字符串发送给对象，实际开发中，信息相对更复杂，
	// 一般会选用Json、xml等方式进行更好的支持
	// 字符串解析成结构信息
	ChatInfo rInfo;
	istringstream iss(str);
	iss >> rInfo._name >> rInfo._id  >> rInfo._msg;
	cout << "-------------------------------------------------------"<< endl;
	cout << "姓名：" << rInfo._name << "(" << rInfo._id << ") ";
	cout << rInfo._name << ":>" << rInfo._msg << endl;
	cout << "-------------------------------------------------------"<< endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

这样就很顺利将复杂的数据统一成字符串进行发送！

1. stringstream实际是在其底层维护了一个string类型的对象用来保存结果。
2. 多次数据类型转化时，一定要用clear()来清空，才能正确转化，但clear()不会将stringstream底层的string对象清空。
3. 可以使用s. str("")方法将底层string对象设置为""空字符串。
4. 可以使用s.str()将让stringstream返回其底层的string对象。
5. stringstream使用string类对象代替字符数组，可以避免缓冲区溢出的危险，而且其会对参数类型进行推演，不需要格式化控制，也不会出现格式化失败的风险，因此使用更方便，更安全。