【C++中的IO流和文件操作精讲】

最新推荐文章于 2024-08-25 23:11:21 发布

三眼五显仙人~

最新推荐文章于 2024-08-25 23:11:21 发布

阅读量685

点赞数 30

分类专栏： C++初阶文章标签： c++

本文链接：https://blog.csdn.net/qq_64446981/article/details/138129262

版权

C++初阶专栏收录该内容

26 篇文章 1 订阅

订阅专栏

【本节目标】

1. C语言的输入与输出

2. 流是什么

3. C++IO流

4. stringstream的简单介绍

1. C语言的输入与输出

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

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

⭐printf(): 将指定的文字/字符串输出到标准输出设备(屏幕)。注意宽度输出和精度输出控制。

C语言借助了相应的缓冲区来进行输入与输出。如下图所示：

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

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

2. 流是什么

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

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

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

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

3. C++IO流

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

3.1 C++标准IO流

C++标准库提供了4个全局流对象cin、cout、cerr、clog

⭐使用cout进行标准输出，即数据从内存流向控制台(显示器)。

⭐使用cin进行标准输入即数据通过键盘输入到程序中，

⭐使用cerr用来进行标准错误的输出，

⭐使用clog进行日志的输出，

从上图可以看出cout、 cerr、clog是ostream类的三个不同的对象，因此这三个对象现在基本没有区别，只是应用场景不同。

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

注意：

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

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

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

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

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

6. 在线OJ中的输入和输出：

对于IO类型的算法，一般都需要循环输入：
输出：严格按照题目的要求进行，多一个少一个空格都不行。
连续输入时，vs系列编译器下在输入ctrl+Z时结束

// 单个元素循环输入
while (cin >> a)
{
	// ...
}
// 多个元素循环输入
while (cin >> a >> b >> c)
{
	// ...
}
// 整行接收
while (cin >> str)
{
	// ...
}

随后我们再来看一下operator bool的返回值，我们会发现这里如果没成功就会设置一些标记位，那我们来看看有一些什么样的标记位

在 C++ 中，ios_base 类为输入/输出流提供了一组错误状态位。这四个错误状态位是：

eofbit (end-of-file bit)：当到达文件结尾时设置。例如，当从文件中读取数据时，如果已经读取了所有数据，eofbit 将被设置为 true。
failbit (failure bit)：当遇到非致命错误时设置。例如，如果尝试从文件中读取数据，但文件无法打开，failbit 将被设置为 true。
badbit (bad bit)：当遇到致命错误时设置。例如，如果尝试写入到只读文件中，badbit 将被设置为 true。
goodbit：当没有错误时设置。当 eofbit、failbit 和 badbit 都没有被设置时，goodbit 被设置为 true。

它们之间的区别在于错误的严重程度：

eofbit 代表正常操作的结束，并非错误。
failbit 代表非致命错误，通常可以恢复。
badbit 代表致命错误，通常无法恢复。

我们来演示一下：

// 流的默认标志都是goodbit
int main()
{
	int i = 0;
	int j = 0;
	cout << "初始状态: " << cin.good() << endl;
	// 要求整型输入整型正常读取，此时就是goodbit
	cin >> i;
	cout << i << endl;
	cout << "正常输入状态: " << cin.good() << endl;
	// 要求整型输入字符型非正常读取，此时就不是goodbit
	cin >> j;
	cout << j << endl;
	cout << "非正常输入状态: " << cin.good() << endl;
	return 0;
}

我们来看一下输出结果：

我们可以来看下这几个标志位对应的行为，以及相应的函数的状态

我们可以使用库中提供的clear函数来恢复到最初的标记位

那么此时我们再此进行输入可以吗？

我们会发现此时依然是错误的，并且上面再输入abc之后并没有让我们再次输入，而是直接输出结果，为什么呢？因为clear函数只会重置我们的标记位，并不会去影响缓冲区的数据，所以此时缓冲区的数据依然存在，再次读取的时候读取的就还是abc，此时依然会输出错误，此时我们可以想办法将缓冲区的数据情况，但是我们不能使用fflush去清空，因为他是刷新输出缓冲区的，而我们这里是刷新输入缓冲区的，我们这里需要使用get()函数。

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

istream& operator>> (int& val);
explicit operator bool() const;

实际上我们看到使用while(cin>>i)去流中提取对象数据时，调用的是operator>>，返回值是 istream类型的对象，那么这里可以做逻辑条件值，源自于istream的对象又调用了operator bool，operator bool调用时如果接收流失败，或者有结束标志，则返回false。

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

sync_with_stdio是C++中的一个功能，通常在使用标准输入输出流（如cin和cout）时被提及。这个功能与标准I/O库（stdio.h或stdio.hpp）的同步有关，后者是C语言的输入输出库，也被C++所兼容。在C++中，std::ios_base::sync_with_stdio(false)可以被用来禁用C++ I/O与C标准I/O之间的同步。默认情况下，这两个I/O系统是同步的，这意味着当你同时使用cin/cout和scanf/printf时，它们会互相等待，确保操作不会重叠。这对于混合使用C和C++风格的输入输出的程序来说是有帮助的，但也会带来性能上的开销，尤其是在大量数据处理时。

取消缓冲区同步：C++标准I/O流的缓冲区刷新不再影响C标准I/O的缓冲区，反之亦然。这意味着如果一个缓冲区满或需要刷新，它不会触发另一个缓冲区的刷新。
取消线程同步：在多线程环境中，这会取消C++标准I/O和C标准I/O之间的锁机制，允许它们独立操作而不必等待对方。

需要注意的是，一旦你调用了std::ios_base::sync_with_stdio(false)，C++的I/O流和C的I/O函数就不再同步了。这意味着如果你在cin和cout之后使用了scanf或printf，可能会导致未预期的行为，因为缓冲区可能不会像你期望的那样刷新。

3.2 C++文件IO流

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

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

// 读取一个文件内容

#include<fstream>
int main()
{
	std::ifstream ifs;
	ifs.open("Test.cpp");
	char ch;
	while (ifs.get(ch))
	{
		cout << ch;
	}

	ifs.close();

	std::ifstream ifs("Test.cpp");
	char ch;
	//while (ifs>>ch)//空格和换行认为是多个值，会忽略它
	while (ifs.get(ch))
	{
		cout << ch;
	}
}

我们再去尝试读一下图片，但是并没有显示出来，为什么呢？因为图片不是一个文本文件，而是一个二进制文件。

#include<fstream>
#include <iostream>
using namespace std;
int main()
{
	std::ifstream ifs("seg.png", ios_base::in | ios_base::binary);
	//std::ifstream ifs("Test.cpp");
	char ch;
	//while (ifs>>ch)
	size_t n = 0;
	while (ifs.get(ch))
	{
		++n;
		cout << ch;
	}

	cout << endl << endl;
	cout << n<< endl;

}

此时由于一些前面字符的影响，导致我们没有打印出结果n

但是我们有调式功能呀！用它来。

此时确实已经读到了，只不过我们的黑框框显示不出来。

结束绑定使用cin.tie(nullptr)。

IO效率提高的做法，不够我们日常OJ的时候不需要这样。

#include <iostream>
using namespace std;

int main()
{
	// 再IO需求比较高的地方，如部分大量输入的竞赛题当中，加上以下3句代码
	// 可以提高C++IO效率
	std::ios_base::sync_with_stdio(false);
	// 默认情况下cout和cin都是绑定的
	cin.tie(nullptr);
	cout.tie(nullptr);
	return 0;
}

接下来我们就来看看文件流的一些使用细节。

# include <iostream>
# include <fstream>

using namespace std;

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，则结束
		// while(cin >> x),返回的对象是istream对象，该对象会调用operator bool()
		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]; // 32位ip地址
	//string _address; //二进制，不能读写string,写到文件是一个指针，再读回来，就一个野指针

	int _port; // 端口号
	Date _date; // 日期类
};

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

	// 二进制写，内存中是什么样子，就按字节一个一个写出去
	// 写文件使用ofstream
	void WriteBin(const ServerInfo& info)
	{
		ofstream ofs(_filename, ios_base::out | ios_base::binary);
		ofs.write((const char*)&info, sizeof(info));
	}

	// 二进制读，硬盘文件中是什么样子，就按字节一个一个读出来
	// 读文件使用ifstream
	void ReadBin(ServerInfo& info)
	{
		ifstream ifs(_filename, ios_base::in | ios_base::binary);
		ifs.read((char*)&info, sizeof(info));
	}

	// C++文件流的优势就是可以对内置类型和自定义类型，都使用
	// 一样的方式，去流插入和流提取数据
	// 当然这里自定义类型Date需要重载>> 和 <<
	// istream& operator >> (istream& in, Date& d)
	// ostream& operator << (ostream& out, const Date& d)

	// 写
	void WriteText(const ServerInfo& info)
	{
		ofstream ofs(_filename);
		// 内置类型直接使用即可
		ofs << info._address << endl;
		ofs << info._port << endl;
		ofs << info._date << endl; // 对于Data自定义类型已经重载流插入
	}
	// 读
	void ReadText(ServerInfo& info)
	{
		ifstream ifs(_filename);
		// 内置类型直接使用即可
		ifs >> info._address;
		ifs >> info._port;
		ifs >> info._date; // 对于Data自定义类型已经重载流提取
	}

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

我们再来分别进行二进制读写

int main()
{
	// 二进制写
	ServerInfo wbinfo = { "192.168.1.10", 80, { 2024, 7, 15 } };
	ConfigManager cf_bin("test.bin");
	cf_bin.WriteBin(wbinfo); // 二进制写文件

	// 二进制读
	// 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, { 2024, 7, 15 } };
	ConfigManager cf_text("test.text");

	cf_text.WriteText(winfo);

	// 文本读
	// ConfigManager cf_text("test.text");
	ServerInfo rtinfo;
	cf_text.ReadText(rtinfo);
	cout << rtinfo._address << " " << rtinfo._port << " " << rtinfo._date << endl;
	return 0;
}

我们来看一下运行结果：

当我们在程序中处理字符串时，我们通常认为它们是一串字符，以空字符\0作为结尾。在C语言或类似的语言中，字符串本质上是一个字符数组的别名。然而，在内存中，字符串实际上只是一个指向该字符数组起始位置的指针。

当你将一个字符串“写入”到二进制文件中，如果只是简单地保存字符串变量本身（即指针），而不是实际的字符数据，那么你实际上是在文件中存储了一个内存地址。这个地址在你的程序运行环境中是有意义的，它指向当前进程内存空间中字符串的实际位置。

问题在于，当你关闭程序并再次打开二进制文件读取这个地址时，原始的内存地址已经失去了意义。操作系统会在每次程序运行时分配不同的内存区域给进程，这意味着之前存储的地址现在很可能不再指向任何有效的数据，从而导致一个野指针（dangling pointer）。野指针是指向不可访问或不确定的内存位置的指针，访问这样的指针会导致未定义行为，比如程序崩溃。

为了避免这个问题，正确的做法是将字符串的内容（即字符数组中的所有字符，包括结束符\0）写入文件，而不是字符串的地址。这样，无论何时读取文件，你都会得到字符串的实际内容，而不会遇到无效的指针。

现在有一个细节问题来了，为什么这里传入的是ofstream的对象，却能够传参给ostream类型的对象呢？在C++中，ofstream类实际上是ostream类的一个子类。ofstream继承自ostream，并且添加了一些额外的功能，特别是那些与文件输出相关的功能。这意味着ofstream对象拥有ostream的所有属性和方法，那这里是继承还是多态呢？首先我们要了解多态的条件：

必须通过基类的指针或者引用调用虚函数
被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

此时我们虽然满足第一个条件，但是第二个条件我们就不满足，我们调用的函数并不是虚函数，所以这里就是一个继承，我们这里就是典型的是一个继承，直接去调用父类的方法。

3.3. stringstream的简单介绍

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

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

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

在C++中，可以使用stringstream类对象来避开此问题。在程序中如果想要使用stringstream，必须要包含头文件。在该头文件下，标准库三个类： istringstream、ostringstream 和 stringstream，分别用来进行流的输入、输出和输入输出操作，本文主要介绍stringstream。 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对象中
	cout << sa << endl;
	s.str("");
	s.clear();
	// 清空s, 不清空会转化失败
	double d = 12.34;
	s << d; // 将d写入到s
	s >> sa; // 将从s中读取的数据给sa,会覆盖掉之前sa的内容
	string sValue;
	sValue = s.str();
	// str()方法：返回stringsteam中管理的string类型
	cout << sValue << endl;

	cout << sa << endl;
	return 0;
}

2. 字符串拼接

# include <sstream>

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

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

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

# include <sstream>

// 结构体转化为字符串
int main()
{
	ostringstream oss;
	ChatInfo winfo = { "张三",123456, {2024, 7, 19}, "咱们一起打游戏吧!" };
	// 此时不是写到我们的控制台当中，而是转化为字符串写入到ostringstream里面
	oss << winfo._name << " " << winfo._id << " " << winfo._date << " " << winfo._msg;
	// 怎么拿到呢？使用str()函数
	string str = oss.str();
	cout << str << endl;
	return 0;
}

我们来看一下运行结果：

其实我们看到这里就会发现上面的ostringstream实际上就是我们网络里面的序列化，将用户端输入的内容转为字符串，这样我们才能将数据发送出去，那服务端收到数据就需要反序列化，将字符串再转化为客户端输入的内容进行处理，那么接下来我们就需要进行反序列化

// 结构体转化为字符串
int main()
{
	ostringstream oss;
	ChatInfo winfo = { "张三",123456, {2024, 7, 19}, "咱们一起打游戏吧!" };
	// 此时不是写到我们的控制台当中，而是转化为字符串写入到ostringstream里面
	// 序列化 
	oss << winfo._name << " " << winfo._id << " " << winfo._date << " " << winfo._msg;
	// 怎么拿到呢？使用str()函数
	string str = oss.str();
	cout << str << endl;

	// 通过网络套接字给服务端，服务端读取之后需要解析 - 反序列化

	istringstream iss(str);
	ChatInfo rinfo;
	//  此时不是从键盘读，而是从istringstream里面读
	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;
}

我们来看一下运行结果：

但是此时我们要注意一个点，如果我们此时从istringstream中读取的顺序和结构体中的变量定义的顺序不一样，此时结果是错误的。

此时我们读取的是一个字符串，但是我们用整形去接受，此时就会出现错误，此时goodbit标志位就会被置为0，这里我们可以来验证一下这几个比特位。

此时我们就需要使用上面提到过的clear函数去重置一下标志，此时按照正常的顺序去读才不会出现问题。

注意：

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