C++ IO流

目录

一、C语言的输入与输出

二、流

三、C++IO流

3.1 C++标准IO流

3.2 C++文件IO流

3.3 stringstream字符串流

一、C语言的输入与输出

        在 C 语言中，最常用的输入输出函数是 scanf() 和 printf()。它们分别用于从标准输入读取数据，以及将数据输出到标准输出。

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

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

C语言借助了相应的缓冲区来进行输入与输出：

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

1. 屏蔽底层 I/O 差异，提高程序可移植性
   操作系统提供的低级输入输出（如 read()、write() 系统调用）是依赖具体平台和内核实现的，如果程序频繁直接调用它们，不同系统之间很难兼容。通过在用户空间设置输入输出缓冲区，程序可以调用如 scanf()、printf() 等标准库函数，这些函数在底层使用缓冲机制屏蔽了具体的系统调用差异，可以很容易写出可移植的程序；
2.  支持更高层次的数据结构和操作，例如“行”读取
   对于底层 I/O（如 read()），系统只管字节流，并不关心什么是“行”、“字段”、“分隔符”等。我们可以定义“行”的概念（以 \n 为一行的结束符），就可以在缓冲区中处理字符，直到遇到换行符再返回给程序。

二、流

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

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

三、C++IO流

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

3.1 C++标准IO流

        C++ 标准库为输入输出操作提供了四个常用的全局对象，它们分别属于 iostream 头文件中的类，主要用于与标准设备（如终端、控制台）进行数据交互。

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

注意：

关于输入流：

1. cin为缓冲流。键盘输入的数据保存在缓冲区中，按下回车键表示输入完成。一旦按下回车，缓冲区内容就已提交，不能再修改。调用 cin >> 变量 时，程序会从缓冲区中提取需要的数据，若输入的数据超过提取量，多余的数据会保留在缓冲区中，等待下一次提取使用。
2. 如果用户输入的数据类型不匹配，程序出错。输入流会在流的状态字（state bits）中对应位置位（置1），标记出错，不会终止程序，但后续的输入将失效。
3. 空格和回车都可以作为数据之间的分格符，所以多个数据可以在一行输入，也可以分行输入。但如果是字符型和字符串，则空格（ASCII码为32）无法用cin输入，字符串中也不能有空格，回车符也无法读入。

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

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

class A
{
public:
	friend istream& operator>>(istream& in, A& a);
	friend ostream& operator<<(ostream& out, const A& a);
private:
	int _a;
};

istream& operator>>(istream& in, A& a)
{
	in >> a._a;
	return in;
}
ostream& operator<<(ostream& out, const A& a)
{
	out << a._a;
	return out;
}
int main()
{
	A a;
	cin >> a;
	cout << a << endl;
	return 0;
}

在在线OJ中，经常看到这样的循环输入：

// 整行接收
while(cin>>str)
{
    // ...
}

连续输入时，vs系列编译器下在输入ctrl+Z，再按一次回车就可以结束。

 疑问：while的表达式结果应该是bool类型，上面这种方式是怎么做到的？

类型转换：

1. C++ 中一些内置类型可以隐式转换为 bool

while (1);// int,float等-> 0为false，非0为true
while (nullptr); // 指针-> 空指针为false，非空为true

2. 类型转换运算符 可以 让自定义类型的对象隐式或显式地转换成某个内置类型或其他类型

语法：（Type就是这个函数的返回值类型）

operator Type() const;

例如重载了 operator bool() 的类对象可以作为 while 的表达式：

class MyBool
{
public:
	operator bool()
	{
		return true;
	}
};
int main()
{
	MyBool obj;
	while (obj);
	return 0;
}

再看这个OJ例子，cin >> str 实际上就是 operator>>(cin,str) ，调用的是下面这个函数：

istream& operator>> (istream& is, string& str);

它返回了istream类型对象的引用，而istream重载了bool类型运算符：

explicit operator bool() const;

istream隐式转换为bool类型，从而实现了循环输入。operator bool 调用时如果接收流失败，或者有结束标志，那么就返回 false。

注意：虽然 explicit 使得隐式转换失效，但在 if (a)、while (a) 等条件语句中，仍然允许隐式调用。explicit 只避免因意外类型转换导致的错误，比如直接赋值给bool变量。

C++浮点数精度控制：

用于获得/设置浮点数精度（有效数字个数）：

double pi = 3.141592653589793;

cout << "默认精度: " << pi << '\n'; // 3.14159
cout << "当前精度: " << cout.precision() << endl;// 6

cout.precision(5);// 设置精度为5
cout << "精度设为5: " << pi << '\n';//  3.1416

fixed 的作用：把浮点数以定点形式输出，即精度表示的是小数点后保留的位数。与流上的插入（<<）和提取 （>>）操作结合使用。

double pi = 3.141592653589793;

cout << std::fixed;// 切换为定点格式
cout.precision(3);
cout << pi << '\n'; //3.142 保留3位小数

//通常和setprecision(n)搭配使用（头文件<iomanip>）
cout << std::fixed << setprecision(2) << pi << endl; //保留2位小数:3.14

std::ios_base::sync_with_stdio 用于控制 C++ 标准流（如 cin, cout）是否与 C 标准流（如 scanf, printf）同步 。即控制 C++ I/O是否和 C I/O共享缓冲区。

默认是同步的，即共享缓冲区，这样可以保证混用时的输出顺序正确。

在不使用 scanf/printf 的情况下，关闭同步可以加速输入输出，提高 cin/cout 的性能。（通常提升 2~5 倍速度）

std::ios::sync_with_stdio(false);  // 关闭同步
std::cin.tie(nullptr);             // 解除 cin 和 cout 的绑定

.tie() 用于管理两个流之间的刷新依赖关系，默认cin绑定cout，即每次cin前，cout会自动刷新缓冲区。解除绑定，即省去了刷新开销。

3.2 C++文件IO流

        C++根据文件内容的数据格式分为二进制文件和文本文件。标准库提供了<fstream>头文件，其中定义了文件流类（如std::ifstream、std::ofstream和std::fstream），用于方便地操作文件。

文件流类：

• std::ifstream：用于从文件读取数据（读）。
• std::ofstream：用于向文件写入数据（写）。
• std::fstream：用于同时进行文件的读写操作。

这些类都是从std::iostream派生而来，因此它们继承了标准I/O流的大部分功能。

以 ifstream 为例：

ifstream 的带参构造有两个参数，第一个参数 filename 是要打开的文件名，第二个参数 mode 表示文件打开模式 。ifstream默认是读取模式，ofstream 默认是写入模式。

可以组合使用多个模式（用 | 运算符）。

相较于C语言的fread、fwrite等文件操作而言，C++的优势是可以通过重载流插入 << 和流提取 >> 来实现自定义类型的输入输出（需要重载<<、>>）。

class A
{
public:
	A(){}
	A(string s, int a) :_s(s), _a(a) {}
	friend istream& operator>>(istream& in, A& a);
	friend ostream& operator<<(ostream& out, const A& a);
private:
	string _s;
	int _a;
};

istream& operator>>(istream& in, A& a)
{
	in >> a._s >> a._a;
	return in;
}
ostream& operator<<(ostream& out, const A& a)
{
	out << a._s << " " << a._a;
	return out;
}

int main()
{
    // 文本读写
	A a1("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz",123);
	std::ofstream fout("a.txt");// 以写的方式打开a.txt
	fout << a1;// 将a1的内容以文本形式写到a.txt
	fout.close();  // 显式关闭写文件

	A a2;
	std::ifstream fin("a.txt"); // 以读的方式打开a.txt
	fin >> a2;// 将a.txt的内容以文本形式读到a2中
	cout << a2 << endl;// 验证
	return 0;
}

fout << a1会在当前目录创建a.txt，并把a1的内容写进去。虽然fout的析构会自动关闭写文件，但是立刻读取可能出现还没写完就读取的情况，所以这里手动关闭写文件来刷新缓冲区。

 C++输入流默认用空格和换行符等作为分隔符，所以前面这串字符被读取到a2._s，123被读取到a2._a。如果想自定义分隔符，可以使用std::getline。

上面这种方式是文本读写，好处是便于我们观察，缺点是速度较慢，因为需要格式转换。

二进制读写（binary）的是原始内存字节流，不管类型，因此速度更快，但是人看不懂。

二进制读写用 read() 和 write() 函数，操作字节。从这两个函数也能看出来，istream只能读， ostream只能写。

istream& read (char* s, streamsize n);

ostream& write (const char* s, streamsize n);

s表示要读写的指针，n就是要读写的字节数。

int a, b;
a = 123456789;
ofstream fout("b.txt", std::ios::out | std::ios::binary);// 以二进制写的格式
fout.write((char*)&a, sizeof(a));
fout.flush();// flush可以强制刷新缓冲区

ifstream fin("b.txt", std::ios::in | std::ios::binary);// 以二进制读的格式
fin.read((char*)&b, sizeof(b));
cout << b << endl;// 验证

b.txt中就是二进制代码（显示出来是乱码）：

这里有一个值得注意的地方，当二进制读取的一个结构体中有string类型时，不能直接用char*强转，string里的字段有一个char*指针，当从文件里写入时，其实是把这个指针以二进制方式写了进去，当再从文件里读取时，就读取到了同一个地址造成浅拷贝的情况。

class Data
{
public:
	Data() {}
	Data(string s) :_data(s) {}
private:
	string _data;
};
int main()
{
	Data d1("https://legacy.cplusplus.com/reference/istream/istream/read/?kw=read");
	ofstream fout("c.txt", std::ios::out | std::ios::binary);// 以二进制写的格式
	fout.write((char*)&d1, sizeof(d1));
	fout.flush();// flush可以强制刷新缓冲区

	Data d2;
	ifstream fin("c.txt", std::ios::in | std::ios::binary);// 以二进制读的格式
	fin.read((char*)&d2, sizeof(d2));
	return 0;
}

这段代码中d2._data与d1._data指向同一块地址，在析构时对同一块地址析构二次导致程序崩溃。

如果非要以二进制形式读写，那么就要手动控制：

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

class Data
{
public:
    Data() {}
    Data(string s) : _data(s) {}

    // 写入到二进制文件
    void writeToStream(ofstream& out) const {
        size_t len = _data.size();
        out.write(reinterpret_cast<const char*>(&len), sizeof(len));   // 写入字符串长度
        out.write(_data.c_str(), len);                                 // 写入字符串内容
    }

    // 从二进制文件读取
    void readFromStream(ifstream& in) {
        size_t len = 0;
        in.read(reinterpret_cast<char*>(&len), sizeof(len));           // 读取字符串长度
        string temp(len, '\0');
        in.read(&temp[0], len);                                        // 读取字符串内容
        _data = temp;
    }

    void print() const {
        cout << _data << endl;
    }

private:
    string _data;
};

int main()
{
    Data d1("https://legacy.cplusplus.com/reference/istream/istream/read/?kw=read");

    ofstream fout("c.txt", ios::binary);
    d1.writeToStream(fout);
    fout.close();

    Data d2;
    ifstream fin("c.txt", ios::binary);
    d2.readFromStream(fin);
    fin.close();

    d2.print();  // 验证是否读取成功

    return 0;
}

ifstream 和 ofstream 的无参构造通常结合.open() 使用。

ifstream fin;  // 还没打开文件

string filename;
cin >> filename;

fin.open(filename);  // 根据输入的文件名打开
if (fin.is_open()) {
    // 读取内容
}

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

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

头文件：<sstream>

在该头文件下，标准库三个类：istringstream、ostringstream 和 stringstream。分别用来进行流的输入、输出和输入输出操作。这里介绍 stringstream。

stringstream 提供了一个可以像文件一样操作的字符串缓冲区，通过流操作符 << 和 >> 对字符串进行格式化操作，它是在内存中的字符串里读写。

用途：

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

int n = 123456789;
string s;

// 将一个整形变量转化为字符串，存储到string类对象中
stringstream ioss;
ioss << n;
ioss >> s;

cout << s << endl;
cout << ioss.str() << endl;// .str()方法返回stringsteam中管理的string类型

2. 字符串拼接

stringstream sstream;
// 将多个字符串放入 sstream 中
sstream << "first" << " " << "string,";
sstream << " second string";
cout << "strResult is: " << sstream.str() << endl;
// 清空 sstream
sstream.str("");// .str()方法也可以设置stringstream中的内容,设置""清空原本的内容
sstream << "third string";
cout << "After clear, strResult is: " << sstream.str() << endl;

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

// 定义日期结构
struct Date {
    int year;
    int month;
    int day;

    // 重载输出运算符
    friend ostream& operator<<(ostream& os, const Date& date) {
        os << date.year << " " << date.month << " " << date.day;
        return os;
    }

    // 重载输入运算符
    friend istream& operator>>(istream& is, Date& date) {
        is >> date.year >> date.month >> date.day;
        return is;
    }
};

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

int main() {
    // 结构信息序列化为字符串
    ChatInfo winfo = { "张三", 135246, { 2025, 6, 1 }, "过儿童节" };
    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 << "-------------------------------------------------------" << endl;
    cout << "姓名：" << rInfo._name << "(" << rInfo._id << ") ";
    cout << rInfo._date << endl;
    cout << rInfo._name << ":>" << rInfo._msg << endl;
    cout << "-------------------------------------------------------" << endl;

    return 0;
}

• stringstream 实际上在其底层维护了一个 std::string 类型的缓冲区，用于保存输入或输出的内容。
• 多次进行数据类型转换（如多次使用 >> 读取不同内容）时，如果遇到失败或读到末尾，必须调用 clear() 来重置流的状态为 goodbit，否则后续的读写操作将无法进行。比如将"abc"读到了int中，那么后续的读取将失效。.clear()是用于状态清理的，不会清空底层的string内容。
• 如果要对底层string清理，可以使用. str("")方法将底层string对象设置为""空字符串。
• .str()可以让stringstream返回其底层的string对象。
• stringstream使用string类对象代替字符数组，可以避免缓冲区溢出的危险，而且其会对参数类型进行推演，不需要格式化控制，也不会出现格式化失败的风险，因此使用更方便，更安全。