C++进阶篇11---IO流

一、对C语言的输入输出的理解

C语言中我们经常用 scanf 和 printf 进行输入输出，形象的描述它们的作用如下

对于缓冲区的理解：

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

二、流的概念

• "流"即是流动的意思，是物质从一处向另一处流动的过程，是对一种有序连续且具有方向性的数据的抽象描述。
• C++流是指信息从外部输入设备（如键盘）向计算机内部（如内存）输入和从内存向外部输出设备（显示器）输出的过程。这种输入输出的过程被形象的比喻为“流”。
• 它的特性是：有序连续、具有方向性
• 为了实现这种流动，C++定义了I/O标准类库，库中每个类都称为流/流类，用以完成某方面的功能

（cerr用来做错误输出，clog用来做日志输出，但是需要做配置）

注意：

1. cin为缓冲流。键盘输入的数据保存在缓冲区中，当要提取时，是从缓冲区中拿。如果一次输入过多，会留在那儿慢慢用，如果输入错了，必须在回车之前修改，如果回车键按下就无法挽回了。只有把输入缓冲区中的数据取完后，才要求输入新的数据

2. 输入的数据类型必须与要提取的数据类型一致，否则出错。出错只是在流的状态字state中对应位置位（置1），程序继续。

3. 空格和回车都可以作为数据之间的分格符，所以多个数据可以在一行输入，也可以分行输入。但如果是字符型和字符串，则空格（ASCII码为32）无法用cin输入，字符串中也不能有空格。回车符也无法读入。

4. cin和cout可以直接输入和输出内置类型数据，原因：标准库已经将所有内置类型的输入和输出全部重载了。

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

#include<iostream>
using namespace std;

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

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

ostream& operator<<(ostream& out, const Date& date)
{
	out << date._year << "年" << date._month << "月" << date._day << "日" << endl;
	return out;
}

int main()
{
	Date d;
	cin >> d;
	cout << d;
	return 0;
}

6.可以循环输入数据，输入ctrl+z表示输入结束

	while (cin >> x)
	{
		//...
	}

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

这里就需要讲一下类型转换的几种形式：

• 内置类型之间，类型相近就能相互转换【隐式类型转化/显示类型转换/用C++中的类型转化】
• 自定义类型之间，可以通过构造函数进行类型转换，内置类型转自定义类型也是同理
• 自定义类型转内置类型，如何转？这里C++提供了operator type()这样一个成员函数，如下

class A
{
public:
	A(int x):_x(x){}
	operator bool()
	{
		return _x > 10; // 可以自己实现逻辑
	}
private:
	int _x;
};

int main()
{
	A a(10);
	if (a)
		cout << "a>10";
	else
		cout << "a<=10";
	return 0;
}

库中提供了istream => bool 的类型转换函数，故istream对象能作为判断条件

 三、文件IO流

(仅仅是介绍一下简单的读写方法，具体的还得去结合文档去查找自己需要的函数)

1、二进制读写

// 我们可以将输入输出封装成一个类方便使用，下面是一个简单二进制文件读写的封装
template<class T>
class BinIO
{
public:
	BinIO(string filename)
        :_filename(filename)
	{}

	void Write(const T& tmp)
	{
		ofstream ofs(_filename, ofstream::out | ofstream::binary);
		ofs.write((char*)&tmp, sizeof(tmp));
		ofs.close();
	}

	void Read(T& tmp)
	{
		ifstream ifs(_filename, ofstream::in | ofstream::binary);
		ifs.read((char*)&tmp, sizeof(tmp));
		ifs.close();
	}

private:
	string _filename;
};

使用如下

struct A
{
	int _x;
	double _y;
	char _s[20];
};

int main()
{
	A a = { 10,3.14,"zxws-yyds" };
	BinIO<A> bin("test.txt");
	bin.Write(a);
	A a1;
	bin.Read(a1);
	cout << a1._x << endl;
	cout << a1._y << endl;
	cout << a1._s << endl;
	return 0;
}

确实也能读写出来，但是如果我们将结构体A中的char[]换成string容器就会出现问题，如下

struct A
{
	int _x;
	double _y;
	//char _s[20];
	string _s;
};

int main()
{
	A a = { 10,3.14,"zxws-yyds" };
	BinIO<A> bin("test.txt");
	bin.Write(a);
	A a1;
	bin.Read(a1);
	cout << a1._x << endl;
	cout << a1._y << endl;
	cout << a1._s << endl;
	return 0;
}

显然代码退出异常，为什么？ 这里就要清楚string容器中存放的是什么(不清楚的可以去看C++入门篇7---string类，里面有string的模拟实现)，是ptr，size，capacity，也就是说string中并没有存具体数据，存的是指针，所以我们写文件的时候也是写的指针，这就导致我们在读的时候，读出了相同的地址，出现了浅拷贝问题，导致析构时，空间被释放了两次

同时，如果我们的读写在两个进程中分别执行，那么就会导致野指针的问题，因为两个进程的地址空间是不一样的，在写进程中该地址确实有效，但是在读进程中该指针指向的地址确是不合法的。

这是二进制读写容易犯得问题，只能说在存容器数据的时候要小心，因为容器一般不存放具体数据

2、文本读写

template<class T>
class TextIO
{
public:
	TextIO(string filename) :
		_filename(filename)
	{}

	void Write(const T& tmp)
	{
		ofstream ofs(_filename);
		ofs << tmp;
		ofs.close();
	}

	void Read(T& tmp)
	{
		ifstream ifs(_filename);
		ifs >> tmp;
		ifs.close();
	}

private:
	string _filename;
};

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

istream& operator>>(istream& in, Date& date)
{
	in >> date._year >> date._month >> date._day;
	return in;
}
ostream& operator<<(ostream& out, const Date& date)
{
    // out << date._year << "年" << date._month << "月" << date._day << "日" << endl; 
    //方便读
	out << date._year << " " << date._month << " " << date._day  << endl;
	return out;
}

int main()
{
	TextIO<Date>text("test.txt");
	Date d(2024, 4, 7);
	text.Write(d);
	Date d1;
	text.Read(d1);
	cout << d1;
	return 0;
}

四、stringstream

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

int main()
{
	int a = 10;
	string str;
	stringstream ss;
	ss << a;
	ss >> str;
	cout << str << endl;

	ss.clear();
	// clear()
	// 注意多次转换时，必须使用clear将上次转换状态清空掉
	// stringstreams在转换结尾时(即最后一个转换后),会将其内部状态设置为badbit
	// 因此下一次转换是必须调用clear()将状态重置为goodbit才可以转换
	// 但是clear()不会将stringstreams底层字符串清空掉
	ss.str("");
	// s.str("");
	// 将stringstream底层管理string对象设置成"", 
	// 否则多次转换时，会将结果全部累积在底层string对象中

	double y = 3.14;
	ss << y;
	ss >> str;
	cout << str << endl;
	return 0;
}

2. 字符串拼接

int main()
{
	stringstream ss;
	string name = "张三";
	int age = 20;
	double height = 1.74;
	ss << "姓名：" << name << " 年龄:" << age << " 身高：" << height;
	cout << ss.str() << endl;
	return 0;
}

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

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

	ChatInfo rinfo;
	istringstream iss(str);
	iss >> rinfo._name >> rinfo._id >> rinfo._date >> rinfo._msg;
	cout << rinfo._name << " " << rinfo._id << " " << rinfo._date << " " << rinfo._msg;
	return 0;
}

注意：

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