C++ 的IO流（标准IO流 和文件IO流）

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

scanf(): 从标准输入设备 ( 键 盘 ) 读取数据，并将值存放在变量中 。

printf(): 将指定的文字 / 字符串输出到标准输出设备 ( 屏幕 ) 。

注意宽度输出和精度输出控制。 C 语言借助了相应的缓冲区来进行输入与输出。如下图所示：

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

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

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

流是什么

        流是对 一种有序连续且具有方向性的数据（ 其单位可以是bit,byte,packet ） 的抽象描述。 C++流是指信息从外部输入设备（如键盘）向计算机内部（如内存）输入和从内存向外部输出设 备（显示器）输出的过程。这种输入输出的过程被形象的比喻为“流”。

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

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

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;
}

C++文件IO流(ifstream ofstream fstream)

C++根据文件内容的数据格式分为二进制文件和文本文件。

        1、二进制文件里面是任意的字符,二进制文件是把内存中的数据按其在内存中的存储形式原样输出到磁盘上存放，也就是说存放的是数据的原形式。

        2、文本文件里面没有特殊字符，都是ascii靠后的文本字符，都能打印来。我们说文本文件是特殊的二进制文件，是因为文本文件实际上的解释格式已经确定了：ASCII或者unicode编码。文本文件是把数据的终端形式的二进制数据输出到磁盘上存放，也就是说存放的是数据的终端形式。

         从存储方式来说，文件在磁盘上的存储方式都是二进制形式，所以，文本文件其实也应该算二进制文件。先从他们的区别来说，虽然都是二进制文件，但是二进制代表的意思不一样。 二进制读写是将内存里面的数据直接读写入文本中，而 文本呢，则是将数据先转换成了字符串，再写入到文本中。

采用文件流对象操作文件的一般步骤：

1. 定义一个文件流对象

        在文件形式的读写中 ，怎么用cout cin就怎么用 ifstream 对象和 ofstream 对象（cout和cin从某种意义上来说 ，是一种特殊的文件流对象 ）

        

     

 1. ifstream ifile(只输入用)

int main()
{
	//读文件
	ifstream ifs("test.cpp");

	while (!ifs.eof())
	{
		char c = ifs.get();
		cout << c;
	}
	return 0;
}

 2. ofstream ofile(只输出用)

int main()
{
	//两种写方式ofsteam
	ofstream ofs;
	ofs.open("test_12_23");

	ofs.put('s');
	ofs.write("hello\n",6);
	ofs << "world\n" << endl;

 
	ofstream ofs2("test_12_24");
	ofs2.put('s');
	ofs2.write("hello\n", 6);
	ofs2 << "world\n" << endl; 
 
	ofs.close();
	ofs2.close();
	return 0;
}

        fstream iofile(既输入又输出用) 一般分开用前两个。

#include<fstream>
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[32];
	//string _address;错误使用，string长的时候是有可能是深拷贝 ，文件里就是存了一个地址
	//二进制存储不能存深拷贝，写出去的是地址

	int _port;
	Date _date;
};

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

	// 二进制读写
	// 内存中怎么存，囫囵吞枣，怎么写出去（写到磁盘上）
	void WriteBin(const ServerInfo& info)
	{
		ofstream ofs(_filename, ios_base::out | ios_base::binary);//默认是文本写，二进制需要或binary
		ofs.write((const char*)&info, sizeof(info));//将结构体强转成字符流 ，输出到磁盘上
	}

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


	// C++文件流的优势就是可以对内置类型和自定义类型，都使用
   // 一样的方式，去流插入和流提取数据
   // 当然这里自定义类型Date需要重载>> 和 <<
	void WriteText(const ServerInfo& info)
	{
		ofstream ofs(_filename);
		ofs << info._address << " " << info._port << " " << info._date;
	}

	void ReadText(ServerInfo& info)
	{
		ifstream ifs(_filename);
		ifs >> info._address >> info._port >> info._date;//空格或者换行是数据与数据的分割
	}

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

int main()
{
	ServerInfo winfo = { "192.0.0.1111111111111111111111", 80, { 2022, 4, 10 } };

	// 二进制写
	ConfigManager cf_bin("test.bin");
	cf_bin.WriteBin(winfo);

	return 0;
}

int main()
{
	// 二进制读
	ConfigManager cf_bin("test.bin");

	ServerInfo rbinfo;
	cf_bin.ReadBin(rbinfo);

	cout << rbinfo._address << " " << rbinfo._port << " " << rbinfo._date << endl;

	return 0;
}

int main()
{
	ServerInfo winfo = { "192.0.0.1", 80, { 2022, 4, 10 } };

	// 文本写
	ConfigManager cf_text("test.text");
	cf_text.WriteText(winfo);

	return 0;
}

int main()
{
	//文本写
	ConfigManager cf_text("test.text");
	ServerInfo rtinfo;
	cf_text.ReadText(rtinfo);
	cout << rtinfo._address << " " << rtinfo._port << " " << rtinfo._date << endl;

	return 0;
}

在 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;
}

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

在程序中如果想要使用stringstream，必须要包含头文件。

在该头文件下，标准库三个类： istringstream、ostringstream 和 stringstream，分别用来进行流的输入、输出和输入输出操作，与C++文件流使用不同，一般我们统一使用stringstream

ostringstream 将数据转成字符串

istringstream 将字符串中数据读出

#include<sstream>
int main()
{
    int i = 123;
    Date d = { 2022, 4, 10 };
    ostringstream oss;
    oss << i << endl;
    oss << d << endl;//空格或者换行是数据与数据的分割

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

    istringstream iss(s);
    int j;
    Date x;
    iss >> j >> x;
    cout << j <<' ' << x << endl;//空格或者换行是数据与数据的分割
    //istringstream iss;
    //iss.str("100 2024 9 9");

    istringstream iss2("100 2024 9 9");
    int j2;
    Date x2;
    iss2 >> j2 >> x2;
    cout << j2 << ' ' << x2 << endl;
    return 0;
}

stringstream主要可以用来：

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

#include<sstream>
int main()
{
	int a = 12345678;
	string sa;
	// 将一个整形变量转化为字符串，存储到string类对象中
	stringstream s;
	s << a;
	s >> sa;
	// clear()
	// 注意多次转换时，必须使用clear将上次转换状态清空掉
	// stringstreams在转换结尾时(即最后一个转换后),会将其内部状态设置为badbit
	// 因此下一次转换是必须调用clear()将状态重置为goodbit才可以转换
	// 但是clear()不会将stringstreams底层字符串清空掉

	// s.str("");
	// 将stringstream底层管理string对象设置成"", 
	// 否则多次转换时，会将结果全部累积在底层string对象中

	s.str("");
	s.clear();  // 清空s, 不清空会转化失败
	double d = 12.34;
	s << d;
	s >> sa;
	string sValue;
	sValue = s.str();// str()方法：返回stringsteam中管理的string类型
	cout << sValue << endl;
	return 0;
}

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 ChatInfo
{
	string _name; // 名字
	int _id;      // 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;
	// send(str);

	// str = recv()
	ChatInfo rInfo;
	istringstream 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. stringstream实际是在其底层维护了一个string类型的对象用来保存结果。

        2. 多次数据类型转化时，一定要用clear()来清空，才能正确转化，但clear()不会将  stringstream底层的string对象清空。

        3. 可以使用s. str("")方法将底层string对象设置为""空字符串。

        4. 可以使用s.str()将让stringstream返回其底层的string对象。

        5. stringstream使用string类对象代替字符数组，可以避免缓冲区溢出的危险，而且其会对参 数类型进行推演，不需要格式化控制，也不会出现格式化失败的风险，因此使用更方便，更安全。