目录
1、C输入输出
C语言中用到的很频繁的输入输出方式就是scanf ()与printf()。scanf()是从标准输入设备(键盘)读取数据，并将值存放在变量中。printf()是将指定的文字或字符串输出到标准输出设备(屏幕)。C语言借助了相应的缓冲区来进行输入与输出。
对输入输出缓冲区的理解：
1、可以屏蔽掉低级I/O的实现，低级I/O的实现依赖操作系统本身内核的实现，所以如果能够屏蔽这部分的差异，可以很容易写出可移植的程序。
2、可以使用这部分的内容实现"行"读取的行为，对于计算机而言是没有"行"这个概念，有了这部分，就可以定义"行"的概念，然后解析缓冲区的内容，返回一个"行"。
2、流是什么
"流"即是流动的意思，是物质从一处向另一处流动的过程，是对一种有序连续且具有方向性的数据的抽象描述。C++流是指信息从外部输入设备（如键盘）向计算机内部（如内存）输入和从内存向外部输出设备（显示器）输出的过程。这种输入输出的过程被形象的比喻为"流"。 它的特性是：有序连续、具有方向性。
为了实现这种流动，C++定义了I/O标准类库，这些每个类都称为流或流类，用以完成某方面的功 能。
3、C++IO流
C++有一个庞大的类库，其中ios由ios_base派生而来，istream和ostream由ios派生而来，iostream则继承了istream和ostream，fstream和stringstream又继承自iostream，如下图所示：
其中cin和cout、cerr、clog都是被定义出的全局对象。iostream主要用于终端或者控制台的输入输出，fstream主要用于文件的输入输出，sstream主要用于与格式控制相关的内容。
注：终端一般是Linux中的叫法，控制台一般是Windows中的叫法。
3.1、标准IO流
C++标准库提供了4个全局流对象cin、cout、cerr、clog。使用cout进行标准输出，即数据从内存流向控制台(显示器)。使用cin进行标准输入即数据通过键盘输入到程序中。同时C++标准库还提供了cerr用来进行标准错误的输出，以及clog进行日志的输出。从上图可以看出，cout、 cerr、clog是ostream类定义出的三个对象，因此这三个对象基本没有区别，使用也是一致的，只是应用场景不同。
注意：
1、cin和cout可以直接输入和输出内置类型数据，原因：标准库已经将所有内置类型的输入和输出全部重载了。对于自定义类型，如果要支持cin和cout的标准输入输出，需要对<<以及>>进行重载。
2、在线OJ中的输入和输出：对于IO类型的算法，一般都需要循环输入。连续输入时，vs系列编译器下在输入 ctrl+z+换行 结束。
例如：
cpp
int main()
{
cerr << "hello" << endl;
clog << "hello" << endl;
cout.put('x');
int a, b, c;
while (cin >> a >> b >> c)
{
cout << a << ":" << b << ":" << c << endl;
}
return 0;
}运行结果为：
3、istream类型对象转换bool值
可以作逻辑判断的类型有：bool类型、整形、指针。使用while(cin>>i)，cin>>i的返回值是istream类型的对象，那为什么istream类型的对象可以作判断呢？类型转换可以分为三种：
第一种：有关联的内置类型间的转换，分隐式类型转换和显示类型转换。这个前面的文章已经讲过。
第二种：其他类型转换为自定义类型。使用构造函数即可实现这种转换。
第三种：自定义类型转换为内置类型。使用operator type()实现。
例如：
cpp
class C
{
public:
C(int x)
{}
};
class D
{
public:
D(const C& c)
{}
};
class E
{
public:
operator int() // 这个不算是运算符重载，可以看作是一种特殊的用法。用来做类型转换。
{
// .....
return 1;
}
};
int main()
{
// 内置类型转换为自定义类型
C c1 = 11;
string s1 = "xxx";
// 自定义类型转换为自定义类型
D d1 = c1;
// 自定义类型转内置类型
E e1;
int i = e1;
cout << i << endl;
return 0;
}实际上我们看到使用while(cin>>i)去流中提取对象数据时，调用的是operator>>，返回值是istream类型的对象，那么这里可以做逻辑条件值，就源自于istream的对象又调用了operator bool，发生了类型转换，把istream对象转变成为了一个bool值，如下图所示：
正常输入返回的都是真，输入ctrl+z+换行或者遇到错误就会返回假。
例如：
cpp
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;
}
int main()
{
Date d(2022, 4, 10);
while (d)
{
cin >> d;
cout << d << endl;
}
return 0;
}运行结果为：
4、同步状态
有如下函数，该函数的作用是切换与stdio流的同步状态。
cpp
bool sync_with_stdio (bool sync = true);默认情况下，是同步的，开启同步时，C++ 流和 C 流在内部会使用一致的顺序来处理输入输出，保证在两种接口混用时的可预测性，但是性能会较低一些，因为要维护这种一致性。
关闭同步可以提升IO的性能，但在同一程序中混合使用C和C++的IO，可能会导致输入和输出的顺序出现错乱。
3.2、文件IO流
C++根据文件内容的数据格式分为二进制文件和文本文件。
文本文件是指数据以字符的 ASCII 码（或其他字符编码，如UTF-8）形式存储。文本文件的内容可被人类直接阅读（用文本编辑器打开时显示为字符）。读写需编码转换，速度较慢。
二进制文件是指数据以内存中的原始二进制形式直接存储，不经过字符编码转换。内容是原始字节序列，直接用文本编辑器打开会显示乱码。读写速度快。
3.2.1、二进制读写
例如：
cpp
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;
}
struct ServerInfo
{
char _address[1024];
double _x;
Date _date;
};
class BinIO // 二进制读写
{
public:
BinIO(const char* filename = "info.bin")
:_filename(filename)
{}
void Write(const ServerInfo& winfo)
{
ofstream ofs(_filename, ios_base::out | ios_base::binary); //或者ofstream ofs(_filename, ofstream::out | ofstream::binary);
ofs.write((char*) & winfo, sizeof(winfo));
}
void Read(ServerInfo& rinfo)
{
ifstream ifs(_filename, ios::in | ios::binary);
ifs.read((char*)&rinfo, sizeof(rinfo));
}
private:
string _filename;
};
void Bin_test01() // 写
{
ServerInfo winfo = { "https://legacy.cplusplus.com/reference/fstream/fstream/fstream/", 12.13, { 2022, 4, 10 } };
BinIO bin;
bin.Write(winfo);
}
void Bin_test02() // 读
{
ServerInfo rinfo;
BinIO bin;
bin.Read(rinfo);
cout << rinfo._address << endl;
cout << rinfo._x << endl;
cout << rinfo._date << endl;
}
int main()
{
Bin_test01();
Bin_test02();
return 0;
}运行结果如下：
info.bin文件如下：
注意：二进制读写需要注意的是STL中的容器，例如string这个容器，在上面的代码中将char _address[1024]改为string _address，如下
cpp
struct ServerInfo
{
// char _address[1024];
string _address;
double _x;
Date _date;
};然后进行下面的操作。
1、同一个进程进行读写操作。
运行程序，程序的运行结果为：
原因是string所指向的内容在读之前就已经被释放了，因此读的内容是错误的，另外最终还析构了两次，因此程序就崩溃了。
在上面程序的基础上，将main函数中的内容改为如下：
cpp
int main()
{
ServerInfo winfo = { "https://legacy.cplusplus.com/reference/fstream/fstream/fstream/", 12.13, { 2022, 4, 10 } };
BinIO bin1;
bin1.Write(winfo);
ServerInfo rinfo;
BinIO bin2;
bin2.Read(rinfo);
cout << rinfo._address << endl;
cout << rinfo._x << endl;
cout << rinfo._date << endl;
return 0;
}运行结果为：
这次读到的内容是正确的，但是发生了浅拷贝，最终会被析构两次，因此程序就崩溃了。
2、不同的进程：一个进程写，然后再让另一个进程去读。
先完成写操作，main函数改为如下内容：
cpp
int main()
{
Bin_test01();
return 0;
}再完成读操作，main函数中代码改为如下内容：
cpp
int main()
{
Bin_test01();
return 0;
}运行结果为：
原因是会有野指针的问题，所以程序出错。
二进制的方式读写数据不仅仅是string会出现这样的问题，其他的容器也是类似，不能用二进制的方式进行读写。原因就是容器中并未存储数据的内容，而存储的是维护数据内容的字段。
3.2.2、文本读写
例如：
cpp
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;
}
struct ServerInfo
{
char _address[1024];
double _x;
Date _date;
};
class TextIO // 文本读写
{
public:
TextIO(const char* filename = "info.text")
:_filename(filename)
{
}
void Write(const ServerInfo& winfo)
{
ofstream ofs(_filename);
ofs << winfo._address << endl;
ofs << winfo._x << endl;
ofs << winfo._date << endl;
}
void Read(ServerInfo& rinfo)
{
ifstream ifs(_filename);
ifs >> rinfo._address;
ifs >> rinfo._x;
ifs >> rinfo._date;
}
private:
string _filename;
};
void Text_01()
{
ServerInfo winfo = { "https://legacy.cplusplus.com/reference/fstream/fstream/fstream/", 12.13, { 2022, 4, 10 } };
TextIO text;
text.Write(winfo);
}
void Text_02()
{
ServerInfo winfo;
TextIO text;
text.Read(winfo);
cout << winfo._address << endl;
cout << winfo._x << endl;
cout << winfo._date << endl;
}
int main()
{
Text_01();
Text_02();
return 0;
}运行结果为：
info.text文件内容如下：
3.2、字符串流
在C语言中，如果想要将一个变量的数据转化为字符串格式，如何去做？ 例如：使用sprintf()函数 但是在转化时，需要先给出保存结果的空间，那空间要给多大呢，就不太好界定， 而且转化格式不匹配时，可能还会得到错误的结果甚至程序崩溃。
例如：
cpp
int main()
{
int n = 123456789;
char s1[32];
sprintf(s1, "%d", n);
printf("%s\n", s1);
char s2[32];
sprintf(s2, "%f", n);
printf("%s\n", s2);
return 0;
}运行结果为：
在C++中，标准库三个类：istringstream、ostringstream 和 stringstream，分别用来进行流的输入、输出和输入输出操作，本文主要介绍stringstream。stringstream主要可以用来：
3.2.1、数值类型转化为字符串
例如：
cpp
int main()
{
// 将一个整形变量转化为字符串，存储到string类对象中
int a = 12345678;
string sa;
stringstream s;
s << a;
s >> sa;
cout << sa << endl;
s.str(""); // 将stringstream底层管理string对象设置成"", 否则多次转换时，会将结果全部累积在底层string对象中。
s.clear(); // 注意多次转换时，必须使用clear将上次转换状态清空掉。但是clear()不会将stringstreams底层字符串清空掉。
double d = 12.34;
s << d;
s >> sa;
string sValue;
sValue = s.str(); // 返回stringsteam中管理的string类型。
cout << sValue << endl;
return 0;
}运行结果为：
3.2.2、字符串拼接
cpp
int main()
{
stringstream sstream;
// 将多个字符串放入 sstream 中
sstream << "first" << " " << "string,";
sstream << " second string";
cout << "str: " << sstream.str() << endl;
// 清空 sstream
sstream.str("");
sstream << "third string";
cout << "After str: " << sstream.str() << endl;
return 0;
}运行结果为：
3.2.3、序列化和反序列化
简单来讲，把各种信息转化为字符串的过程就是序列化，把字符串的信息进行还原的过程就是反序列化。例如：
cpp
struct ChatInfo
{
string _name; // 名字
int _id; // id
Date _date; // 时间
string _msg; // 聊天信息
};
int main()
{
ChatInfo winfo = { "张三", 135246, { 2022, 4, 10 }, "晚上一起看电影吧" };
stringstream oss;
oss << winfo._name << endl;
oss << winfo._id << endl;
oss << winfo._date << endl;
oss << winfo._msg << endl;
cout << oss.str() << endl;
ChatInfo rinfo;
string str = oss.str();
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;
}运行结果为：
注：在实际的开发中，信息是很复杂的，一般会选用json来进行支持，并不会用这一块的内容。简单的序列化和反序列化是可以用这一块的内容的。
注意：
1、stringstream实际是在其底层维护了一个string类型的对象用来保存结果。
2、多次数据类型转化时，一定要用clear()来重置内部状态，才能正确转化，但clear()不会将 stringstream底层的string对象清空。可以使用s.str("")方法将底层string对象设置为""空字符串。
3、可以使用s.str()将让stringstream返回其底层的string对象。
4、stringstream使用string类对象代替字符数组，可以避免缓冲区溢出的危险，而且其会对参数类型进行推演，不需要格式化控制，也不会出现格式化失败的风险，因此使用更方便，更安全。