【C++】C++的IO流

喜欢的点赞，收藏，关注一下把！

1. C语言的输入与输出

C语言中我们用到的最频繁的输入输出方式就是scanf ()与printf()。 scanf(): 从标准输入设备(键盘)读取数据，并将值存放在变量中。printf(): 将指定的文字/字符串输出到标准输出设备(屏幕)。注意宽度输出和精度输出控制。C语言借助了相应的缓冲区来进行输入与输出。如下图所示：

对输入输出缓冲区的理解：

1.可以屏蔽掉低级I/O的实现，低级I/O的实现依赖操作系统本身内核的实现，所以如果能够屏蔽这部分的差异，可以很容易写出可移植的程序。

2.可以使用这部分的内容实现“行”读取的行为，对于计算机而言是没有“行”这个概念，有了这部分，就可以定义“行”的概念，然后解析缓冲区的内容，返回一个“行”。

C的这一套是面向过程的。

2.流是什么

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

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

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

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

3.C++IO流

C++系统实现了一个庞大的类库，其中ios为基类，其他类都是直接或间接派生自ios类

C++这一套是面向对象的。

3.1C++标准IO流

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

在使用时候必须要包含文件并引入std标准命名空间。

注意：

1. cin为缓冲流。键盘输入的数据保存在缓冲区中，当要提取时，是从缓冲区中拿。如果一次输入过多，会留在那儿慢慢用，如果输入错了，必须在回车之前修改，如果回车键按下就无法挽回了。只有把输入缓冲区中的数据取完后，才要求输入新的数据。
2. 输入的数据类型必须与要提取的数据类型一致，否则出错。出错只是在流的状态字state中对应位置位（置1），程序继续。
3. 空格和回车都可以作为数据之间的分格符，所以多个数据可以在一行输入，也可以分行输
   入。但如果是字符型和字符串，则空格（ASCII码为32）无法用cin输入，字符串中也不能有空格。回车符也无法读入。
4. cin和cout可以直接输入和输出内置类型数据，原因：标准库已经将所有内置类型的输入和输出全部重载了:

5. 对于自定义类型，如果要支持cin和cout的标准输入输出，需要对<<和>>进行重载。

string类重载了流插入和流提取运算符，因此我们可也以直接用。其他STL容器输入没有重载这两个运算符不能直接用，但是有更好用的迭代器用着更爽。

6. istream类型对象转换为逻辑条件判断值

看下面一段代码，循环什么时候结束呢？

int main()
{
	string str;
	while (cin >> str)
	{
		cout << str << endl;
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10

学过linux我们知道可以使用ctrl+c给进程发信息，默认动作就是进程退出。
有点暴力。

这里更正常的操作是ctrl+z+换行

ctrl+z+换行，是怎么让这个结束这个循环的呢？

返回的是一个istream的对象。其实返回的就是cin。那cin这个对象是如何在这里做条件判断的呢？

之前用作条件判断的类型是整型、指针、bool值。那现在是一个自定义类型，自定义类型是不能做条件逻辑判断，但是istream这个类C++支持一个隐式类型转换的成员函数。其实这还不是istream这个类的而是它从ios这个基类继承而来的。

里面有一个operator void*，还有opeator bool的成员函数。

C++98就支持了自定义类型隐式类型转换成内置类型。
支持istream这个类型转换 void*、bool值，来做这个条件判断。

void*，bool也不是我们熟悉的运算符重载，感觉有点怪，()才是我们熟悉的强转的类型。但是()已经被仿函数占用了，迫不得已只能用这两个的了。

下面我们看看是如何隐式类型转换的

我们知道构造函数不仅可以初始化，而且还支持隐式类型转换

class A
{
public:
	A(int a)
		:_a1(1)
		,_a2(2)
	{}

private:
	int _a1;
	int _a2;
};
1
2
3
4
5
6
7
8
9
10
11
12

内置类型隐式类型转换成自定义类型

int main()
{
	// 内置类型隐式类型转换成自定义类型
	A aa1 = 1;
	return 0;
}
1
2
3
4
5
6

本来是先把1构造成A类的临时对象，然后再拷贝构造。但是编译器优化直接调用构造。但严格来说就是内置类型隐式类型转换自定义类型。当然这里是由于A类有单参数的构造才能支持隐式类型，如果没有就会报错。

自定义类型隐式类型转换成内置类型

自定义类型本来是不能隐式类型转换成内置类型的。

但是自己可以提供一个支持转换成int的函数

class A
{
public:
	A(int a)
		:_a1(1)
		,_a2(2)
	{}

	operator int()
	{
		return _a1 + _a2;
	}

private:
	int _a1;
	int _a2;
};

int main()
{
	// 内置类型隐式类型转换成自定义类型
	A aa1 = 1;

	// 自定义类型隐式类型转换成内置类型
	int aa = aa1;

	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

因此上面while就是如下面这个流程调用operator boo来作为条件逻辑判断。

我们也可以在自己写的日期类写个支持隐式类型转换的operator bool，让日期类对象也可以作为条件逻辑判断。

class Date
{
	friend ostream& operator << (ostream& out, const Date& d);
	friend istream& operator >> (istream& in, Date& d);
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}

	operator bool()
	{
		// 这里是随意写的，假设输入_year为0，则结束
		if (_year == 0)
			return false;
		else
			return true;
	}
private:
	int _year;
	int _month;
	int _day;
};

istream& operator >> (istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

ostream& operator << (ostream& out, const Date& d)
{
	out << d._year << " " << d._month << " " << d._day;
	return out;
}

// C++ IO流，使用面向对象+运算符重载的方式
// 能更好的兼容自定义类型，流插入和流提取
int main()
{
	// 自动识别类型的本质--函数重载
	// 内置类型可以直接使用--因为库里面ostream类型已经实现了
	int i = 1;
	double j = 2.2;
	cout << i << endl;
	cout << j << endl;

	// 自定义类型则需要我们自己重载<< 和 >>
	Date d(2022, 4, 10);
	cout << d;

	//自己写的类也可以作为条件逻辑判断
	while (d)
	{
		cin >> d;
		cout << d;
	}

	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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

由于C++兼容C，因此cout，cin，printf，scanf可以混着用，但是有可能会导致cout，cin比较慢，因为它要保持同步。printf、scanf有自己的缓冲区，cout、cin也有自己的缓冲区。由于在不同缓冲区如何保持顺序呢，就需要付出一些性能的代价。所以有人说在一些OJ中cout、cin比printf、sacnf效率低一点，因为它要保持这里的同步。这里我们可以使用下面的函数把同步关了。让效率快一点。

3.2C++文件IO流

C++文件IO流比起C有更明显的优势，用着更方便。

C++根据文件内容的数据格式分为二进制文件和文本文件。采用文件流对象操作文件的一般步骤：

1. 定义一个文件流对象
   ifstream ifile(只输入用)
   ofstream ofile(只输出用)
   fstream iofile(既输入又输出用)
2. 使用文件流对象的成员函数打开一个磁盘文件，使得文件流对象和磁盘文件之间建立联系
3. 使用提取和插入运算符对文件进行读写操作，或使用成员函数进行读写
4. 关闭文件

假设有一个服务器的信息，把它写到文件中去，然后在从文件中读。我们这里专门写一个类来实现这里的操作。

下面看看具体如何操作

二进制文件读写操作

二进制读写就是你这个数据在内存中是什么样的直接原模原样的写到文件中去，然后读的时候在读回来。

// 二进制读写
struct ServerInfo
{
	char _address[32];
	int _port;
};

struct ConfigManager
{
public:
	ConfigManager(const char* filename)
		:_filename(filename)
	{}

	void WriteBin(const ServerInfo& info)
	{

	}

private:
	string _filename;//配置文件
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

C++这里有ifstream类，ofstream类。谁是写呢？
ofstream是写(输出)，ifstream是读(输入)。

我们以前打开文件用的C都是open，ofstream写提供了open


第一个参数是打开的文件，第二个参数是打开文件模式

这些都是二进制位可以组合在一起用
in读
out写
binary二进制
ate尾部写
app尾部追加写

还有一种方式就是ofstream类对象在构造的时候直接就打开文件。
如果是无参的构造就可以和open结合起来

	void WriteBin(const ServerInfo& info)
	{
		//这两种写法都可以,out,binary是在基类就定义的,ofstream是继承过来的
		//ofstream ofs(_filename, ofstream::out|ofstream::binary);
		ofstream ofs(_filename, ios_base::out|ios_base::binary);

	}
1
2
3
4
5
6
7

一般我们也不用主动调用close，自定义类型出了作用域会自动调用析构函数。

写调用的ostream的write接口

将s所指向的数组的前n个字符插入流中。

void WriteBin(const ServerInfo& info)
{
	//这两种写法都可以,out,binary是在基类就定义的,ofstream是继承过来的
	//ofstream ofs(_filename, ofstream::out|ofstream::binary);
	ofstream ofs(_filename, ios_base::out|ios_base::binary);
	ofs.write((char*)&info, sizeof(info));
}
1
2
3
4
5
6
7

读调用的是istream的read接口

从流中提取n个字符，并将它们存储在s指向的数组中。

void ReadBin(ServerInfo& info)
{
	ifstream ofs(_filename, ios_base::out | ios_base::binary);
	ofs.read((char*)&info, sizeof(info));
}
1
2
3
4
5

接下来我们看看写的效果

int main()
{
	ConfigManager cm("test.txt");
	ServerInfo winfo = { "192.0.0.1",80 };
	cm.WriteBin(winfo);

	return 0;
}
1
2
3
4
5
6
7
8

看到确实写出去了，但是我们看不懂。只有字符串写出去我们才能看懂，因为内存中的字符串和文件中的字符串是一样的。

我们在读回来看一看

int main()
{
	ConfigManager cm("test.txt");
	//ServerInfo winfo = { "192.0.0.1",80 };
	//cm.WriteBin(winfo);

	ServerInfo rinfo;
	cm.ReadBin(rinfo);
	cout << rinfo._address << endl;
	cout << rinfo._port << endl;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

但是二进制读写这里有一个问题

// 二进制读写
struct ServerInfo
{
	char _address[32];
	int _port;
};
1
2
3
4
5
6

这里没有用string，用了string这里就不能二进制读写
如果用了string这里会把你坑死！同一个进程可以，不同进程就不能读写！

首先是读写不是同一个进程，看一下

// 二进制读写
struct ServerInfo
{
	//char _address[32];
	string  _address
	int _port;
};

// 。。。。

int main()
{
	ConfigManager cm("test.txt");
	ServerInfo winfo = { "192.0.0.1",80 };
	cm.WriteBin(winfo);

	//ServerInfo rinfo;
	//cm.ReadBin(rinfo);
	//cout << rinfo._address << endl;
	//cout << rinfo._port << 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

可以看到可以写，但是写出去的东西已经变了

然后重新运行程序，读进来就有问题了，虽然没有报错值也是对的但是进程是异常退出的。只是没报错而已。

可以换个长一点的数据试试。因为string里面有个buff，短的值只是恰好存到buff里。

都没读到，进程之间异常退出了。

二进制读写就是把这个结构的内容原模原因的写出去。
用string写的就是这个string对象，它里面有个_str是一个指针，如果写的是一个进程把这个指针(地址)写到文件中，读的是另外一个进程在把这个指针从文件中读出来，这个指针已经是一个野指针了！因为之前那个进程都已经销毁了，指针指向一块空间也被释放了。然后读进程来了还在这块空间去读，因此有问题。

如果是同一个进程写出去是一个指针，读回来那个指针又没有被释放。那是可以。

这里虽然打印处理都一样，但是进程还是异常了，这是因为两个string里的_str指向的是同一个空间，这里存在释放两次的问题。

总之二进制读写用string就有问题，所以说二进制读写用数组。

那为什么用数组就没问题呢？
用string写的是指针，指针写出去导致这个问题。如果是用的数组，它是把数组里的内容原模原样的写出去，读的时候是把文件里存的数组内存在读进来。

文本文件读写操作

C++更为推荐用文本读写，文本读写用char，string都是可以的。
但是注意文本读写必须把写的内容转换成字符串！

// 文本读写
struct ServerInfo
{
	//char _address[32];
	string  _address;
	int _port;
};

struct ConfigManager
{
public:
	ConfigManager(const char* filename)
		:_filename(filename)
	{}
	
	void WriteText(const ServerInfo& info)
	{
		ofstream ofs(_filename);
		//。。。
	}


	void ReadText(ServerInfo& info)
	{
		ifstream ofs(_filename);
		//。。。
	}
	
private:
	string _filename;//配置文件
};
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
29
30
31

文本读写构造时就不用自己在传第二个参数了，这里构造函数已经给了缺省值。

要把写的内容转换成字符串有点麻烦，虽然可以用库里面提供的转成字符串的函数，但是这里并不推荐，因为我们有更为简单的玩法。

C++的流重载了流插入和流提取
虽然这个流插入并不是ofstream重载的，但是它继承了ostream，它就可以用。

void WriteText(const ServerInfo& info)
{
	ofstream ofs(_filename);
	ofs << info._address;
	ofs << info._port;		
}
1
2
3
4
5
6

写出去的内容我们也可以看懂

怎么用的cout，就怎么用ofstream。
怎么用的cin，就怎么用ifstream。

就不用在自己把内容转成字符串了，它底层会自动帮我们变成字符串。

流提取也不是ifstream重载的，它是继承了istream，也可以直接用。

void ReadText(ServerInfo& info)
{
	ifstream ofs(_filename);
	ofs >> info._address;
	ofs >> info._port;
}
1
2
3
4
5
6

但是这里怎么读不出来了呢？读出来一个随机值。

就好比我平常在使用cin输入多个值我们都会用空格或者换行分割一下，所以这里在输入的也可以用上。

void WriteText(const ServerInfo& info)
{
	ofstream ofs(_filename);
	ofs << info._address << endl;
	ofs << info._port << endl;
}
1
2
3
4
5
6

现在就可以了。

但是现在有一个要求要写出去的信息里面多个日期类对象。那这个日期类对象怎么写？

// 文本读写
struct ServerInfo
{
	//char _address[32];
	string  _address;
	int _port;

	Date _date;
};
1
2
3
4
5
6
7
8
9

日期类对象有年月日，把这些拿出去分别去写很不方便。

但是这里我们可以不用自己在搞了。前面string我们就知道这个对象，它重载了流插入流提取，因此它可以像内置类型那样直接用。这里我们也可以把日期类的流插入和流提取重载写上，然后就和string一样像内置类型一样直接用流插入流提取了。不过它调用的是自己写的日期类的流插入流提取。

class Date
{
	friend ostream& operator << (ostream& out, const Date& d);
	friend istream& operator >> (istream& in, Date& d);
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}

private:
	int _year;
	int _month;
	int _day;
};

istream& operator >> (istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

ostream& operator << (ostream& out, const Date& d)
{
	out << d._year << " " << d._month << " " << d._day;
	return out;
}

struct ConfigManager
{
public:
	ConfigManager(const char* filename)
		:_filename(filename)
	{}

	
	void WriteText(const ServerInfo& info)
	{
		ofstream ofs(_filename);
		ofs << info._address << endl;
		ofs << info._port << endl;
		ofs << info._date << endl;
	}
	
	
	void ReadText(ServerInfo& info)
	{
		ifstream ofs(_filename);
		ofs >> info._address;
		ofs >> info._port;
		ofs >> info._date;
	}
	
private:
	string _filename;//配置文件
};
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

日期类对象_date传给d，子类对象ofs传给父类对象in。

因此如果想写别的自定义类型到文件中，这个自定义类型需要自己重载流提取和流插入。

其实对比C语言的那套输入输出可以认为C++这套东西就是与其对应的，一个是面向过程一个是面向对象。

4.stringstream的简单介绍

在C语言中，如果想要将一个整形变量的数据转化为字符串格式，如何去做？

1. 使用itoa()函数
2. 使用sprintf()函数

但是两个函数在转化时，都得需要先给出保存结果的空间，那空间要给多大呢，就不太好界定，而且转化格式不匹配时，可能还会得到错误的结果甚至程序崩溃。

int main()
{
	int n = 123456789;
	char s1[32];
	_itoa(n, s1, 10);
	
	char s2[32];
	sprintf(s2, "%d", n);
	
	char s3[32];
	sprintf(s3, "%f", n);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

在C++中，可以使用stringstream类对象来避开此问题。

在程序中如果想要使用stringstream，必须要包含头文件。在该头文件下，标准库三个类：istringstream、ostringstream 和 stringstream，分别用来进行流的输入、输出和输入输出操作。为了方便可以直接用stringstream类对象进行输入出去，不然就用istringstream类对象进行输入，ostringstream类对象进行输出。

1. 将数值类型数据格式化为字符串

这里还是用的流插入流提取，它也是从父类继承过来的。

int main()
{
	int i = 1234;
	Date d = { 2024,3,8 };
	ostringstream oss;
	oss << i<<" ";
	oss << d << " ";//对于自定义类型，自己必须重载了流插入流提取

	return 0;
}
1
2
3
4
5
6
7
8
9
10

现在就是已经把它们俩转成字符串了，只不过这个字符串是在oss这个对象里面。
调用stringstream类的str接口，就可以拿到这个字符串

int main()
{
	int i = 1234;
	Date d = { 2024,3,8 };
	ostringstream oss;
	oss << i<<" ";
	oss << d << " ";

	string str = oss.str();
	cout << str << endl;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

然后我们可以用istringstream进行提取分割，注意它是以空格和换行为结尾的。(把字符串变成格式化的数据)

int main()
{
	//插入
	int i = 1234;
	Date d = { 2024,3,8 };
	ostringstream oss;
	oss << i<<" ";
	oss << d << " ";

	string str = oss.str();
	cout << str << endl;


	int i1;
	Date d1;
	//提取分割(按照空格和\n进行分割)
	istringstream iss(str);
	iss >> i1 >> d1;

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

istringstream构造给个string。相当于把这个string里的内容进行分割

2. 字符串拼接

int main()
{
	stringstream sstream;

	// 将多个字符串放入 sstream 中
	sstream << "first" << " " << "string,";
	sstream << " second string";
	cout << "strResult is: " << sstream.str() << endl;

	// 清空 sstream
	sstream.str("");
	sstream << "third string";
	cout << "After clear, strResult is: " << sstream.str() << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3. 序列化和反序列化结构数据

序列化：将一堆结构的信息，无论是整型、浮点型、自定义类型都转成字符串。
反序列化：将字符串信息转换提取出来。

下面是模仿发送信息

struct ChatInfo
{
	string _name; // 名字
	int _id;      // id
	Date _date;   // 时间
	string _msg;   // 聊天信息

};

int main()
{
	//序列化
	// 结构信息序列化为字符串
	ChatInfo winfo = { "张三", 135246, { 2024, 3, 8 }, "晚上一起看电影吧"};
	stringstream oss;
	oss << winfo._name << " " << winfo._id << " " << winfo._date << " "<< winfo._msg;
	string str = oss.str();
	cout << str << endl << endl;

	//反序列化
	// 我们通过网络这个字符串发送给对象，实际开发中，信息相对更复杂，
	// 一般会选用Json、xml等方式进行更好的支持
	// 字符串解析成结构信息
	ChatInfo rInfo;
	stringstream iss(str);
	iss >> rInfo._name >> rInfo._id >> rInfo._date >> rInfo._msg;
	cout << "-------------------------------------------------------"<< endl;
	cout << "姓名：" << rInfo._name << "(" << rInfo._id << ") ";
	cout << rInfo._date << endl;
	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
27
28
29
30
31
32
33
34

用stringstream实现序列化和反序列化太简单了，实际上用Json、xml等方式进行更好的支持。

注意：

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