C++IO流

零.前言

了解更多C++知识点，欢迎订阅我的专栏：C++编程。
流，是物质从一处流向另一处的过程，是对一种有序连续且具有方向性的数据（其单位可以是bit,byte,packet）的抽象描述。C++流是指信息从外部输入设备（如键盘）向计算机内部（如内存）输入和从内存向外部输入设备（显示器）输出的过程。这种输入输出的过程被形象比喻为"流"。它的特性是：有序连续，具有方向性。
为了实现这种流动，C++定义了I/O标准类库，这些每个类都被称为流/流类，用以完成某方面的功能。

1.cin与cout的本质

在C语言中我们使用的输入输出函数分别是scanf与printf，而在C++中我们使用cin和cout使用>>与<<进行输入和输出。
其中<<表示从内存流向控制台，>>表示从控制台流向内存。
我们可以在文档中找到关于cin和cout的定义：


我们发现，它们分别是istream类和ostream类所定义的两个对象。
我们在两个类中还可以分别找到>>和<<两个运算符的重载，这就是我们可以使用cin>>a来读入数据，以及使用cout<<a来输出数据的原因。
而我们可以使用cout<<输出不同类型的原因就在于对运算符<<重载的函数重载。

int a=1,b=2;
double c=1.1;
cout<<a;//本质上是cout.operatot<<(a)
cin>>b;//本质上是cin.operator>>(b)
cout<<c;//注意与输出a调用的不是一个函数，而是它的重载

内置类型的输入输出的重载函数在库中已经被实现，而自定义类型需要自己去实现。

2.<<与>>的返回值

(1)输入输出多个内容

这里来查看operator<<的文档，>>的同理：

我们发现，operator<<这个函数的返回值都是ostream&类型，由于使用的引用返回，所以其实返回的就是对象cout本身。
这也就是为什么cout可以同时处理多个对象的原因，例如：cout<<a<<b，cout<<a返回的是一个cout，然后再继续cout<<b。

(2)对象作判定条件

在我们刷OJ题的时候，经常会遇到输入情况：

有多组输入样例，输入组数未知。

C语言解决

当我们还在学习C语言的时候是这样解决的：

	int a[10];
	while (scanf("%s", a)!=EOF)
	{
		;
	}

我们使用scanf的返回值来判断循环结束。当有值输入时，scanf会返回参数个数；当读到文件结尾时，scanf会返回EOF。

C++处理

C++的处理一般是这样的：

	string str;
	while (cin >> str)
	{
		;
	}

根据上面描述我们知道，>>的返回值是cin，而cin是一个对象。
我们都知道可以使用变量(0或1)或者指针(空指针或非空指针)来做判断条件，但是为什么使用对象也可以呢？
这是因为有特殊的运算符重载。
当我们使用cin或者cout作为判断条件时，会调用istream或者ostream中的operator bool()函数，注意bool不是一个运算符，所以叫特殊的运算符重载。

该函数的作用就是将对象返回成一个bool类型，false为假，true为真。
我们可以来模拟实现一下：

class B
{
public:
	int a;
	int b;
	operator bool()
	{
		return a != 0;
	}
};
int main()
{
	B b;
	while (b)
	{
		cin >> b.a;
	}
	return 0;
}

其中while循环判定条件b其实就是b.operator bool()，当读到文件结束时会返回false。

3.cout,cin与printf,scanf的对比

1.当我们要进行连续输入输出时，cin和cout是连续的调用重载函数，而scanf和printf只是一个函数所以效率会更高。
2.scanf和printf的缺点是只能支持内置类型。
3.cout和cin的优势是重载之后自定义类型也可以简单实用。

4.C++的文件操作

文件操作介绍四个函数：

以二进制读
以二进制写
以文本读
以文本写

以及含对象的读写。
C语言的方式请参考这篇文章：C文件操作
使用C++进行文件读写需要包含名为fstream的头文件，它其中的ofstream是和ifstream分别是写和读的类。

(1)以二进制进行读写

代码

#include<iostream>
#include<string>
#include<fstream>
using namespace std;
struct ServerInfo
{
	char _ip[32];
	int _port;
};
class ConfigManager
{
public:
	ConfigManager(const char* filename)
		:_filename(filename)
	{}
	void WriteBin(ServerInfo& info)
	{
		ofstream ofs(_filename.c_str(), ios_base::out | ios_base::binary);
		ofs.write((const char*)&info, sizeof(ServerInfo));
	}
	void ReadBin(ServerInfo& info)
	{
		ifstream ifs(_filename.c_str(), ios_base::in | ios_base::binary);
		ifs.read((char*)&info, sizeof(ServerInfo));
	}
private:
	string _filename;
};
int main()
{
	ServerInfo info = { "127.0.0.1",80 };
	ConfigManager cm("config.bin");
	cm.WriteBin(info);
	ConfigManager im("config.bin");
	im.ReadBin(info);
	cout << info._ip << " " << info._port << endl;
}

这段代码表示的就是二进制的读写，下面来解释这段代码。

解释

我们首先定义了一个结构体ServerInfo用于存储数据。并通过ConfigManager来进行文件操作。
其中建立了两个函数WriteBin和ReadBin来进行文件的写和读。
我们首先来看一下使用ostream创建对象时需要进行的初始化（要传入的内容）

可以看到我们需要传入：filename(文件名)和ios_base::openmode mode = ios_base::out后面这一堆东西，很显然这里给的是一个缺省值，所以只需要传入ios_base::out即可，但我们要使用二进制进行打印，因此还需要使用通路来进行设定二进制：
ios_base::out|ios_base::binary

		void WriteBin(ServerInfo& info)
	{
		ofstream ofs(_filename.c_str(), ios_base::out | ios_base::binary);
		ofs.write((const char*)&info, sizeof(ServerInfo));
		//ofs<<info._ip<<" "<<info._port;
	}

这段代码表示的就是我们建立一个对象ofs，用要操作的文件名和操作方式对其进行初始化，然后调用该对象中的写函数，将info的内容写入文件中。其中c_str表示的是转化为C语言的字符串。
我们还可以使用<<操作符来进行读入和读出内容。
同理，

void ReadBin(ServerInfo& info)
	{
		ifstream ifs(_filename.c_str(), ios_base::in | ios_base::binary);
		ifs.read((char*)&info, sizeof(ServerInfo));
		//ifs>>info._ip>>info._port;
	}

表示的是建立一个对象来接收info中的内容，并调用read函数将其读出来。
这段代码打印的结果是：

打开工程我们会发现其中多了一个文件：

由于是二进制文件需要通过计算机转换才能看见。

(2)以文本方式读写

以文本方式读写和二进制比较相似，只需要更改读和写的两个函数即可。

	void WriteTxt(ServerInfo& info)
	{
		ofstream ofs(_filename.c_str());
		ofs << info._ip <<" "<< info._port;
	}

	void ReadTxt(ServerInfo& info)
	{
		ifstream ifs(_filename.c_str());
		ifs >> info._ip >> info._port;
	}

在使用文本文件读写时，就可以使用默认的缺省值了，即不需要再使用ios_base::out这种参数了。同样读入和读出文件也可以使用使用<<和>>。

(3)含对象内容的读写

假如在上方再建立一个日期类，我们希望向文件中传入日期类中的成员变量，但是成员变量一般是私有的，该如何处理呢：

#include<iostream>
#include<string>
#include<fstream>
using namespace std;
class Date
{
	friend ofstream& operator<<(ofstream& ofs, Date& d);
	friend ifstream& operator>>(ifstream& ifs, Date& d);
private:
	int _year;
	int _month;
	int _day;
public:
	Date(int year=2022, int month=1, int day=1)
		:_year(year)
		,_month(month)
		,_day(day)
	{}
};
ofstream& operator<<(ofstream& ofs, Date& d)//重载<<
{
	ofs << d._year << " " << d._month << " " << d._day << endl;
	return ofs;
}
ifstream& operator>>(ifstream& ifs, Date& d)//重载>>
{
	ifs >> d._year >> d._month >> d._day;
	return ifs;
}
struct ServerInfo
{
	char _ip[32];
	int _port;
	Date d;
};
class ConfigManager
{
public:
	ConfigManager(const char* filename)
		:_filename(filename)
	{}
	void WriteTxt(ServerInfo& info)
	{
		ofstream ofs(_filename.c_str());
		ofs << info._ip << " " << info._port;
		ofs<<info.d;
	}
	void ReadTxt(ServerInfo& info)
	{
		ifstream ifs(_filename.c_str());
	    ifs >> info._ip >> info._port;
		ifs >> info.d;
	}
private:
	string _filename;
};
int main()
{
	ServerInfo info = {"127.0.0.1",80};
	ConfigManager cm("confi.txt");
	cm.WriteTxt(info);
	ConfigManager im("confi.txt");
	im.ReadTxt(info);
	cout << info._ip << " " << info._port<<endl;
}

此时我们就需要去重载<<和>>来进行Date类的写入与读出了，重载时需要设置为友元函数，这样才能访问到Date中的变量。
可以使用调试来观察结果：

我们也可以在工程文件夹中找到文件，并查看其中内容：

同时我们发现一个神奇的现象，来看这一段代码：

		ofs << info._ip << " " << info._port;
		ofs<<info.d;

如果我们这样输出是完全没有问题的，但是如果我们将info.d跟在前面进行连续输出的话，就会发生报错，这是由于继承的原因，我们发现它们的继承关系是

我们再来看一下ofstream的<<的操作符重载：

我们发现ifstream压根就没有对ostream中的<<的重载进行重写（没有必要），使用的依然是ostream这个类中的<<。
因此我们就可以理解上述不能连续打印的原因了：
ofs << info._ip返回的是ostream&类型，而不是ifstream&类型，我们重载的是ifstream&类型，因此不能继续打印info._d。要想连续打印，需要将重载函数的iftream&类型转换为ostream类型&。

5.字符串与结构体变量的转换

(1)代码

struct Pinfo
{
	string _name;
	int _age;
};
int main()
{
	Pinfo info = { "张三",18 };
	//将结构体内容转换成字符串
	ostringstream oss;
	oss << info._name<<" "<< info._age;
	string str = oss.str();
	//将字符串转换成结构体类型
	istringstream iss(str);
	Pinfo ofo;
	iss >> ofo._name >> ofo._age;
	cout << ofo._name << " " << ofo._age;
}

(2)解释

注意在使用ostringstream和istringstream的时候要先包含头文件sstream。

将结构体转换成字符串

这里使用的对象是oss，使用<<向oss传入内容，然后调用oss.str()就可以将结构体内容转换成函数。

将字符串转换成结构体

首先定义一个结构体对象ofo，使用iss接收字符串str的内容，然后对ofo进行输入。
我们可以观测一下打印的结果，说明上述操作均已经成功：

6.总结

通过本文我们了解了我们经常使用的cin和cout其实是一个对象，要想了解更多关于原理的地方，我们可以通过cplusplus.com这个网站进行查询，C++的文件操作我们使用的并不多，但是在网络中字符串的转换还是经常使用的。