C++：IO库

一、C++ IO库的架构

C++标准库中的IO系统基于流（Stream）​的概念，分为三层结构：

1. ​流对象​（如cin, cout, fstream）
2. ​流缓冲区​（streambuf，负责底层数据处理）
3. ​数据源/目的地​（如内存、文件、控制台）

主要头文件：

• <ios>：基础IO类定义
• <istream>/<ostream>：输入输出流
• <iostream>：控制台输入输出
• <fstream>：文件流
• <sstream>：字符串流

 二、C++ IO类的层次结构

1. 基础类

• ios_base：这是所有 IO 类的基类，它定义了一些通用的状态标志、格式标志和事件处理机制。它不涉及具体的输入输出操作，主要用于管理和维护 IO 流的状态和格式。
• ios：继承自ios_base，它包含了流的缓冲区指针和一些状态信息，为后续的输入输出操作提供了基础。

2. 输入输出类

• istream：用于输入操作的类，继承自ios。它定义了一系列用于从流中读取数据的成员函数，如operator>>、get、getline等。
• ostream：用于输出操作的类，同样继承自ios。它定义了一系列用于向流中写入数据的成员函数，如operator<<、put等。
• iostream：继承自istream和ostream，它既支持输入操作，也支持输出操作。

3. 文件 IO 类

• ifstream：继承自istream，用于从文件中读取数据。
• ofstream：继承自ostream，用于向文件中写入数据。
• fstream：继承自iostream，支持对文件的读写操作。

4. 字符串 IO 类

• istringstream：继承自istream，用于从字符串中读取数据，就像从输入流中读取一样。
• ostringstream：继承自ostream，用于将数据写入字符串中。
• stringstream：继承自iostream，支持对字符串的读写操作。

层次结构示意图

三、核心基类详解

1. ios_base（位于<ios>）

• ​功能：定义所有流类的公共属性和状态
• ​关键成员：

  // 格式化标志
  fmtflags setf(fmtflags flags); // 设置格式
  streamsize precision(streamsize prec); // 浮点数精度// 流状态
  iostate rdstate() const; // 获取当前状态
  bool good() const;       // 流是否正常
  bool eof() const;        // 是否到达流末尾

2. ios（继承自ios_base，位于<ios>）

• ​功能：管理流缓冲区和错误状态
• ​关键成员：

class ios : public ios_base {
public:// 流状态管理bool good() const;  // 状态正常bool eof() const;   // 到达文件尾bool fail() const;  // 可恢复错误bool bad() const;   // 严重错误void clear(iostate state = goodbit);iostate rdstate() const;// 流缓冲区操作streambuf* rdbuf() const;streambuf* rdbuf(streambuf* sb);
};

职责：

• 维护流状态（goodbit、eofbit、failbit、badbit）
• 管理关联的streambuf对象

---

3、输入输出流基类

1. istream（输入流，位于<istream>）

• ​功能：处理输入操作
• ​关键成员：

  // 基础输入
  istream& operator>>(T& val); // 重载的提取操作符
  int get();                   // 读取单个字符
  istream& getline(char* s, streamsize n); // 读取一行// 高级操作
  streamsize readsome(char* s, streamsize n); // 读取可用数据//简易完整版
  class istream : virtual public ios {
  public:// 基础输入istream& operator>>(int& val);istream& operator>>(string& str);// 非格式化输入int get();istream& get(char& c);istream& getline(char* s, streamsize n);// 高级操作streamsize readsome(char* s, streamsize n);istream& ignore(streamsize n = 1, int delim = EOF);
  };

 关键方法：

• >> 运算符重载（格式输入）
• get() 读取单个字符

2. ostream（输出流，位于<ostream>）

• ​功能：处理输出操作
• ​关键成员：

  // 基础输出
  ostream& operator<<(T val);   // 重载的插入操作符
  ostream& put(char c);         // 输出单个字符// 刷新缓冲区
  ostream& flush();            // 强制刷新缓冲区class ostream : virtual public ios {
  public:// 基础输出ostream& operator<<(int val);ostream& operator<<(const char* str);// 非格式化输出ostream& put(char c);ostream& write(const char* s, streamsize n);// 控制输出位置pos_type tellp();ostream& seekp(pos_type pos);
  };

关键方法：

• << 运算符重载（格式输出）
• put() 输出单个字符
• write() 原始字节输出

 

3. iostream（继承自istream和ostream，位于<istream>）

• ​功能：同时支持输入输出的流（如标准控制台流）

class iostream : public istream, public ostream {
public:// 多继承类，支持双向操作
};

典型应用：

• 标准控制台流cin/cout/cerr的实现

 

四、<< 、>>运算符

1. << 运算符（输出运算符）（像水波扩撒）

基本用途

<< 运算符一般用于向输出流里写入数据，最常见的输出流便是 std::cout，它代表标准输出（通常是控制台）。此运算符把数据发送到输出流，然后输出流会把数据显示在对应的设备上。

语法

output_stream << data;//data->output_stream

这里的 output_stream 是输出流对象，像 std::cout、std::ofstream（用于文件输出）等；data 是要输出的数据，可以是基本数据类型（例如 int、double、char 等），也可以是自定义类型。

示例代码

#include <iostream>int main() {int num = 10;double pi = 3.14;std::string str = "Hello, World!";// 输出整数std::cout << "整数: " << num << std::endl;// 输出浮点数std::cout << "浮点数: " << pi << std::endl;// 输出字符串std::cout << "字符串: " << str << std::endl;return 0;
}

• std::cout << "整数: "：把字符串 "整数: " 发送到标准输出流。
• << num：接着把变量 num 的值发送到标准输出流。
• << std::endl：向标准输出流发送换行符，同时刷新输出缓冲区。

链式调用

<< 运算符支持链式调用，也就是可以连续使用该运算符来输出多个数据。

std::cout << "整数: " << num << ", 浮点数: " << pi << std::endl;

2. >> 运算符（输入运算符）（像水波扩散）

基本用途

>> 运算符通常用于从输入流读取数据，最常见的输入流是 std::cin，它代表标准输入（通常是键盘）。该运算符从输入流中提取数据，并将其存储到指定的变量中。

语法

input_stream >> variable;//input_stream->variable

这里的 input_stream 是输入流对象，如 std::cin、std::ifstream（用于文件输入）等；variable 是要存储数据的变量。

示例代码

#include <iostream>int main() {int num;double pi;std::string str;// 输入整数std::cout << "请输入一个整数: ";std::cin >> num;// 输入浮点数std::cout << "请输入一个浮点数: ";std::cin >> pi;// 输入字符串std::cout << "请输入一个字符串: ";std::cin >> str;// 输出输入的数据std::cout << "你输入的整数是: " << num << std::endl;std::cout << "你输入的浮点数是: " << pi << std::endl;std::cout << "你输入的字符串是: " << str << std::endl;return 0;
}

• std::cin >> num：从标准输入流中读取一个整数，并将其存储到变量 num 中。
• std::cin >> pi：从标准输入流中读取一个浮点数，并将其存储到变量 pi 中。
• std::cin >> str：从标准输入流中读取一个字符串，并将其存储到变量 str 中。
• 注意，>> 运算符在读取字符串时会忽略空白字符（如空格、制表符、换行符等），直到遇到下一个空白字符为止。

链式调用

>> 运算符也支持链式调用，可以连续使用该运算符来读取多个数据。

std::cin >> num >> pi;

3. 自定义类型的 >> 和 << 运算符重载

对于自定义类型，也可以重载 >> 和 << 运算符，以便支持自定义类型的输入输出操作。

示例代码

#include <iostream>
#include <string>class Person {
public:std::string name;int age;// 重载 << 运算符friend std::ostream& operator<<(std::ostream& os, const Person& p) {os << "姓名: " << p.name << ", 年龄: " << p.age;return os;}// 重载 >> 运算符friend std::istream& operator>>(std::istream& is, Person& p) {std::cout << "请输入姓名: ";is >> p.name;std::cout << "请输入年龄: ";is >> p.age;return is;}
};int main() {Person p;std::cin >> p;std::cout << p << std::endl;return 0;
}

• operator<<：这是一个友元函数，用于将 Person 对象的信息输出到输出流中。
• operator>>：这也是一个友元函数，用于从输入流中读取数据，并将其存储到 Person 对象中。

 五、文件流类（<fstream>）

1. ifstream（输入文件流）

class ifstream : public istream {
public:// 文件操作void open(const char* filename, ios_base::openmode mode = ios_base::in);void close();bool is_open() const;
};

• ​典型用法：

  ifstream fin("data.txt");
  if (fin) { // 检查是否成功打开int value;fin >> value;
  }

2. ofstream（输出文件流）

class ofstream : public ostream {
public:// 支持与ifstream类似的文件操作
};

3. fstream（双向文件流）

• 继承自iostream，支持读写操作：

  fstream file("data.txt", ios::in | ios::out);

4.示例：文件复制

ifstream in("source.txt", ios::binary);
ofstream out("dest.txt", ios::binary);if (in && out) {out << in.rdbuf();  // 利用流缓冲区直接复制
}

---

六、字符串流类（<sstream>）

1. istringstream（输入字符串流）

class istringstream : public istream {
public:string str() const; // 获取底层字符串void str(const string& s); // 设置底层字符串
};

2. ostringstream（输出字符串流）

class ostringstream : public ostream {
public:string str() const;
};

3. 典型应用：类型转换

#include <iostream>
#include <sstream>
using namespace std;
int main() {// 使用istringstream和ostringstream进行字符串与数值的转换string input = "42 3.14";istringstream iss(input);int a; double b;iss >> a >> b; // a=42, b=3.14ostringstream oss;oss << "Result: " << a*b;string output = oss.str(); // "Result: 133.56"
}

---

七、流缓冲区类（<streambuf>）

1.基本概念

流缓冲区类为 I/O 流提供了一个数据缓冲区，起到了数据的临时存储和传输的作用。当程序进行输入操作时，数据会先从输入设备（如文件、键盘）读取到流缓冲区中，然后程序再从缓冲区中获取数据；当进行输出操作时，数据会先被写入到流缓冲区，之后再由缓冲区将数据发送到输出设备（如文件、屏幕）。

2.层次结构

<streambuf> 头文件中定义的流缓冲区类形成了一个层次结构，主要的基类是 std::streambuf，它是所有流缓冲区类的基类，提供了通用的缓冲区管理接口。基于 std::streambuf 派生出了不同类型的流缓冲区类，以适应不同的 I/O 设备和操作：

• std::filebuf：用于文件 I/O 的流缓冲区类，管理文件的读写操作。
• std::stringbuf：用于字符串 I/O 的流缓冲区类，管理字符串的读写操作。
• std::wstreambuf：宽字符版本的 std::streambuf，用于处理宽字符的 I/O 操作。
• std::wfilebuf：宽字符版本的 std::filebuf，用于宽字符文件的 I/O 操作。
• std::wstringbuf：宽字符版本的 std::stringbuf，用于宽字符字符串的 I/O 操作。

3.主要成员函数

std::streambuf 类提供了许多成员函数，用于管理缓冲区和进行数据的读写操作:

• 缓冲区指针操作：
  • eback()：返回输入缓冲区的起始指针。
  • gptr()：返回输入缓冲区的当前读取位置指针。
  • egptr()：返回输入缓冲区的结束指针。
  • pbase()：返回输出缓冲区的起始指针。
  • pptr()：返回输出缓冲区的当前写入位置指针。
  • epptr()：返回输出缓冲区的结束指针。
• 缓冲区填充和刷新操作：
  • underflow()：当输入缓冲区为空时，该函数负责从输入设备读取数据填充缓冲区。
  • overflow(int c = traits_type::eof())：当输出缓冲区已满时，该函数负责将缓冲区中的数据写入到输出设备，并刷新缓冲区。
  • sync()：刷新缓冲区，将缓冲区中的数据写入到输出设备。
• 数据读写操作：
  • sgetc()：返回当前输入缓冲区的字符，但不移动读取指针。
  • sbumpc()：返回当前输入缓冲区的字符，并将读取指针向后移动一位。
  • sputc(int c)：将字符 c 写入到输出缓冲区，并将写入指针向后移动一位。
  • sputn(const char_type* s, std::streamsize n)：将字符串 s 中的 n 个字符写入到输出缓冲区。

4.自定义缓冲区（高级用法）

class MyBuffer : public streambuf {
protected:int_type overflow(int_type c) override {// 自定义输出处理return c;}
};// 使用自定义缓冲区
MyBuffer buf;
ostream custom_stream(&buf);
custom_stream << "Hello custom buffer!";

5.使用示例

以下是一个使用 std::filebuf 进行文件读写操作的示例：

#include <iostream>
#include <fstream>
#include <streambuf>int main() {// 打开文件并关联到 filebuf 对象std::filebuf fb;if (fb.open("test.txt", std::ios::out | std::ios::binary)) {// 写入数据到缓冲区const char* data = "Hello, World!";std::streamsize size = std::char_traits<char>::length(data);fb.sputn(data, size);// 刷新缓冲区并关闭文件fb.pubsync();fb.close();}// 打开文件并关联到 filebuf 对象进行读取操作if (fb.open("test.txt", std::ios::in | std::ios::binary)) {// 获取缓冲区的大小std::streamsize size = fb.pubseekoff(0, std::ios::end, std::ios::in);fb.pubseekpos(0, std::ios::in);// 读取数据到缓冲区char* buffer = new char[size];fb.sgetn(buffer, size);// 输出读取的数据std::cout << "读取的数据: " << buffer << std::endl;// 释放缓冲区内存并关闭文件delete[] buffer;fb.close();}return 0;
}

---

 八、IO对象

C++标准库中IO对象不允许拷贝或赋值

---

1、基础现象验证

首先通过代码实验观察现象：

#include <fstream>
using namespace std;int main() {ifstream in1("test.txt");ifstream in2 = in1;          // 编译错误：拷贝构造被禁用ofstream out;out = ofstream("data.txt");  // 编译错误：赋值操作被禁用
}

所有IO类型（如ifstream/ostringstream）均无法进行拷贝构造或赋值操作。

---

2、底层机制分析

1. 类定义实现（以C++11标准为例）

标准库通过删除拷贝控制成员显式禁用拷贝：

namespace std {class basic_ios : public ios_base {// ...basic_ios(const basic_ios&) = delete;          // 拷贝构造删除basic_ios& operator=(const basic_ios&) = delete; // 赋值操作删除};template<typename _CharT, typename _Traits>class basic_ostream : virtual public basic_ios<_CharT, _Traits> {// 同样禁用拷贝构造和赋值};
}

---

3、禁止拷贝的核心原因

1. ​资源唯一性原则

IO对象（如文件流）管理不可复制资源：

• 文件句柄（File Descriptor）
• 流缓冲区（streambuf）指针
• 流状态信息（goodbit/eofbit等）

如果允许拷贝，会导致多个对象操作同一个底层资源：

// 假设允许拷贝的假想场景
ifstream in1("data.txt");
ifstream in2 = in1;in1 >> x;  // 读取部分数据
in2 >> y;  // 无法确定读取位置，导致竞争状态

2. ​状态一致性维护

每个IO对象维护独立状态：

• 当前文件读写位置（tellg()/tellp()）
• 错误状态标记（rdstate()）
• 格式控制标志（如精度、进制）

拷贝会导致状态信息的分裂，难以保证一致性。

3. ​避免资源双重释放

如果允许拷贝，析构时会多次关闭同一个文件句柄：

// 假想允许拷贝的析构场景
{ifstream in1("data.txt");ifstream in2 = in1;
} // in2析构时关闭文件句柄 → in1析构时再次关闭已关闭的句柄 → 未定义行为

---

4、替代方案与正确用法

1. 使用引用传递

void process_input(istream& is) {  // 通过引用操作流int val;is >> val;
}ifstream in("data.txt");
process_input(in);     // 合法：传递引用
process_input(cin);    // 同样适用标准输入流

2. 使用指针传递

void save_data(ostream* os) {*os << "Data: " << 42;
}ofstream out("data.txt");
save_data(&out);       // 显式传递指针

3. 移动语义（C++11+）

虽然标准流对象不可移动，但可自定义包装类：

class StreamWrapper {unique_ptr<ostream> os;
public:StreamWrapper(ostream&& os) : os(os ? new ostream(os.rdbuf()) : nullptr) {}// 实现移动构造/赋值
};StreamWrapper sw1(ofstream("data.txt"));
StreamWrapper sw2 = std::move(sw1);  // 合法移动

4. 共享流缓冲区

多个对象共享同一个流缓冲区（非拷贝对象）：

ifstream in1("data.txt");
ifstream in2(in1.rdbuf());  // 构造新流但共享缓冲区in1.seekg(100);  // 影响in2的读取位置
char c;
in2 >> c;        // 从位置100开始读取

---

5、设计模式对比

类型	拷贝语义	移动语义（C++11）	资源管理方式
std::fstream	❌ 禁止	❌ 禁止	独占资源
std::string	✅ 深拷贝	✅ 移动	值语义（COW优化）
std::shared_ptr	✅ 引用计数	✅ 移动	共享所有权

IO对象采用独占所有权模型，与unique_ptr类似，禁止拷贝以强制明确资源所有权。

---

6、陷阱

1. 函数返回值误区

// 错误示例：返回临时流对象
ifstream open_file(const string& name) {ifstream f(name);return f;  // 尝试拷贝 → 编译错误
}// 正确做法：返回包装类或使用引用参数
void open_file(const string& name, ifstream& out) {out.open(name);
}

2. 容器存储问题

vector<ofstream> streams;  // 编译错误：元素需要可拷贝// 正确做法：存储指针或包装类
vector<unique_ptr<ofstream>> streams;
streams.emplace_back(make_unique<ofstream>("log1.txt"));

---

九、条件状态

1、流状态的核心作用

IO流对象（如ifstream/cin）通过状态标志位实时反映操作结果，开发者可通过这些状态：

1. 检测输入/输出是否成功
2. 区分错误类型（可恢复错误 vs 致命错误）
3. 控制程序流（重试/终止）
4. 实现异常驱动式错误处理

---

2、状态标志位详解

在ios_base类中定义的4个核心状态标志（通过位掩码实现）：

标志位	值	触发场景
goodbit	0x00	流处于正常状态（无错误）
eofbit	0x01	到达文件末尾（End-of-File）或输入流结束（如Ctrl+D）
failbit	0x02	逻辑错误（如类型不匹配），可恢复错误
badbit	0x04	物理错误（如磁盘损坏、无效文件指针），流已不可用

组合状态示例：

• goodbit | eofbit → 无效（实际状态由位运算决定）
• failbit | badbit → 严重错误

---

3、状态检测方法

1. 成员函数检测

ifstream in("data.txt");// 直接检测函数
if (in.good()) { /* 流正常 */ }
if (in.eof())  { /* 到达文件尾 */ }
if (in.fail()) { /* 可恢复错误 */ }
if (in.bad())  { /* 物理损坏 */ }// 综合检测（等价于 !fail() && !bad() ）
if (in) { /* 流可用 */ }  // operator bool()重载

2. 位掩码操作

ios_base::iostate state = in.rdstate();if (state & ios::eofbit) {cout << "到达文件末尾" << endl;
}
if (state & (ios::failbit | ios::badbit)) {cout << "发生错误" << endl;
}

---

4、状态管理操作

1. 状态清除（clear）

int value;
cin >> value;if (cin.fail()) {      // 输入非数字时触发cin.clear();       // 清除错误状态（恢复到goodbit）cin.ignore(1000, '\n'); // 跳过无效输入// 重试逻辑...
}

注意：clear()默认参数为goodbit，可指定具体状态：

in.clear(ios::goodbit | ios::eofbit); // 强制设置特定状态

2. 设置异常掩码（exceptions）

ifstream in;
in.exceptions(ios::failbit | ios::badbit); // 设置触发异常的标志位try {in.open("nonexist.txt");  // 打开失败触发ios::failure异常int val;in >> val;                // 读取失败同样触发异常
} 
catch (const ios::failure& e) {cerr << "IO异常: " << e.what() << endl;
}

---

5、典型应用场景

1. 安全读取循环

vector<int> values;
int tmp;while (cin >> tmp) {  // 自动检测operator>>的返回流状态values.push_back(tmp);
}if (cin.eof()) {cout << "正常结束（到达EOF）" << endl;
} 
else if (cin.fail()) {cout << "输入格式错误" << endl;cin.clear();
}

2. 文件读取容错

ifstream in("data.bin", ios::binary);
char buffer[1024];while (in.read(buffer, sizeof(buffer))) {// 正常处理数据块
}if (in.eof()) {// 处理最后不完整的数据块streamsize count = in.gcount();process(buffer, count);
} 
else if (in.fail()) {cerr << "文件读取错误" << endl;
}

---

6、状态转换机制

1. 状态转换图（简易版）

2. 操作对状态的影响

操作	可能设置的状态位
打开文件失败	failbit
读取到文件末尾	eofbit
类型不匹配	failbit
流缓冲区损坏	badbit
seekg越界	failbit

---

7、调试

1. 输出流状态

void debug_stream_state(const istream& is) {ios::iostate state = is.rdstate();cout << bitset<4>(state) << " : ";if (state & ios::badbit)  cout << "bad ";if (state & ios::failbit) cout << "fail ";if (state & ios::eofbit)  cout << "eof ";if (state == ios::goodbit) cout << "good";cout << endl;
}

2. 结合gdb调试

(gdb) p cout.rdstate()
$1 = std::_Ios_Iostate = 0
(gdb) p cerr.rdstate() 
$2 = std::_Ios_Iostate = 4

---

8、实践

1. ​输入后必检状态：所有operator>>操作后检查流状态
2. ​优先使用getline：避免>>在行末遗留\n导致状态混乱
3. ​异常慎用原则：文件打开等关键操作使用异常，常规错误使用状态检测
4. ​RAII管理状态：利用作用域自动清除临时状态

   {ios::fmtflags old_flags = cout.flags(); // 保存原状态cout << hex << 42;                      // 临时修改// 自动作用域结束恢复
   }

---

关键要点：​始终假设IO操作可能失败，并在代码中显式处理所有可能的错误路径。

 十、文件的输入和输出

 

1、基础 

1. 包含头文件
首先，需要包含 <fstream> 头文件，该头文件定义了文件流类：

#include <fstream>
#include <string>   // 用于字符串操作
#include <limits>   // 用于numeric_limits
using namespace std;

2. 文件流类

• ​ofstream：输出文件流，用于写入文件。
• ​ifstream：输入文件流，用于读取文件。
• ​fstream：多功能文件流，支持读写操作。

文件流对象生命周期

1. 对象创建与文件绑定

// 方式1：构造时打开文件
ofstream out("data.txt", ios::app);  // 追加模式// 方式2：默认构造+后续打开
ifstream in;
in.open("config.ini", ios::in | ios::binary);

2. 对象销毁

{fstream tmp("temp.data");  // 进入作用域时打开文件// 操作文件...
} // 离开作用域时自动调用close()

---

​2、写入文件（输出操作）​

 文件操作

方法	功能描述
open(filename, mode)	打开文件
is_open()	检查文件是否成功打开
close()	关闭文件并刷新缓冲区

步骤示例：​

// 创建输出文件流对象并打开文件
ofstream outFile("example.txt", ios::out); // ios::out 可省略（默认模式）// 检查是否成功打开
if (!outFile.is_open()) {cerr << "无法打开文件！" << endl;return 1;
}// 写入内容
outFile << "第一行内容" << endl;
outFile << "第二行内容\n";
outFile << 42 << " " << 3.14 << endl;// 显式关闭文件
outFile.close();

打开模式（ios 标志位）：​

模式	描述
ios::out	写入模式（默认，覆盖已有内容）
ios::app	追加模式（在文件末尾添加内容）
ios::binary	二进制模式（非文本文件操作）
ios::trunc	清空文件内容（默认与ios::out共用）

---

​3、读取文件（输入操作）​

步骤示例：​

// 创建输入文件流对象并打开文件
ifstream inFile("example.txt");// 检查是否成功打开
if (!inFile) { // 等价于 inFile.fail()cerr << "无法打开文件！" << endl;return 1;
}// 逐行读取内容
string line;
while (getline(inFile, line)) {cout << line << endl;
}// 重置错误状态并关闭文件
inFile.clear(); // 清除可能的EOF或错误标志
inFile.close();

格式化读取示例：​

int num;
double pi;
if (inFile >> num >> pi) {cout << "读取到: " << num << ", " << pi << endl;
} else {cerr << "格式错误！" << endl;inFile.clear();inFile.ignore(numeric_limits<streamsize>::max(), '\n'); // 跳过错误行
}

---

​4、二进制文件操作

写入二进制数据：​

struct Data {int id;char name[20];
};Data data = {1, "Alice"};
ofstream binOut("data.bin", ios::binary);
binOut.write(reinterpret_cast<char*>(&data), sizeof(Data));
binOut.close();

读取二进制数据：​

Data data;
ifstream binIn("data.bin", ios::binary);
binIn.read(reinterpret_cast<char*>(&data), sizeof(Data));
cout << "ID: " << data.id << ", Name: " << data.name << endl;
binIn.close();

---

​5、文件指针操作

随机访问文件：​

fstream file("data.txt", ios::in | ios::out);// 获取当前读取指针位置
streampos pos = file.tellg();// 移动读取指针到第100字节
file.seekg(100, ios::beg);// 移动写入指针到文件末尾
file.seekp(0, ios::end);// 在文件末尾追加内容
file << "\n追加的内容";file.close();

指针定位常量：​

常量	描述
ios::beg	文件开头（默认）
ios::end	文件末尾
ios::cur	当前位置

---

​6、错误处理与状态管理

检测流状态：​

ifstream file("data.txt");if (file.rdstate() == ios::eofbit) {cout << "到达文件末尾" << endl;
} else if (file.rdstate() & ios::failbit) {cerr << "逻辑错误（如类型不匹配）" << endl;
} else if (file.rdstate() & ios::badbit) {cerr << "物理错误（如文件损坏）" << endl;
}file.close();

启用异常处理：​

ifstream file;
file.exceptions(ios::failbit | ios::badbit); // 设置触发异常的标志try {file.open("data.txt");// 文件操作...
} catch (const ios::failure& e) {cerr << "IO异常: " << e.what() << endl;
}

---

​7、实践总结

1. ​RAII原则：利用对象生命周期自动管理资源。

   { // 自动关闭文件ofstream tmpFile("temp.txt");tmpFile << "临时数据";
   }

2. ​路径处理：使用原始字符串或正斜杠避免转义

   ofstream log(R"(C:\Users\Logs\app.log)"); // Windows路径
   ofstream config("/etc/app/config.conf");  // Linux路径

3. ​性能优化：

   // 减少缓冲区刷新次数
   ofstream log("debug.log");
   log << unitbuf; // 自动刷新（慎用）

4. ​跨平台换行符：

   ofstream out("data.txt");
   out << "Line1\r\nLine2"; // Windows换行
   out << "Line3\n";         // Unix/Linux换行

十一、string流

1. 头文件包含

#include <sstream>  // 包含字符串流相关类
#include <string>

---

2. 三类字符串流

• istringstream：从字符串读取数据（输入流）

• ostringstream：向字符串写入数据（输出流）

• stringstream：同时支持读写操作（输入输出流）

---

3. istringstream 使用步骤

场景：将字符串解析为其他类型数据

// 创建输入字符串流并绑定字符串
std::istringstream iss("42 3.14 hello");int num;
double pi;
std::string text;// 像使用cin一样提取数据
iss >> num >> pi >> text;// 验证结果
std::cout << num << " " << pi << " " << text;  // 输出：42 3.14 hello

---

4. ostringstream 使用步骤

场景：将多种类型数据拼接成字符串

std::ostringstream oss;int age = 25;
double score = 95.5;// 像使用cout一样插入数据
oss << "Age: " << age << ", Score: " << score;// 获取最终字符串
std::string result = oss.str();
std::cout << result;  // 输出：Age: 25, Score: 95.5

---

5. stringstream 综合使用

场景：多次读写字符串内容

std::stringstream ss;// 写入数据
ss << "PI: " << 3.14159;// 读取数据
std::string prefix;
double value;
ss >> prefix >> value;// 清空流（重要！）
ss.str("");  // 清空内容
ss.clear();  // 清除错误状态// 重新使用
ss << "New data: " << 100;
std::cout << ss.str();  // 输出：New data: 100

---

6. 关键方法

方法	作用
str()	获取/设置底层字符串
str("content")	重置流内容
clear()	清除错误状态（重要！）

---

7. 典型应用场景

1. 数据格式化：将多个变量组合成格式化的字符串

2. 字符串解析：拆分包含混合数据的字符串（如CSV解析）

3. 类型转换：实现字符串与其他类型的相互转换

// 字符串转数字
std::istringstream("123") >> number;// 数字转字符串
std::ostringstream() << 456).str();

安全类型转换

template <typename T>
T string_to(const string& s) {istringstream iss(s);T value;if (!(iss >> value >> ws).eof()) {throw invalid_argument("无效转换");}return value;
}auto num = string_to<int>("123");  // 成功返回123
auto d = string_to<double>("abc"); // 抛出异常

 复杂字符串解析

void parse_csv(const string& line) {istringstream iss(line);string token;while (getline(iss, token, ',')) {// 处理每个CSV字段process_field(token);}
}

动态字符串构建

string build_sql(const string& table, int id) {ostringstream oss;oss << "SELECT * FROM " << quoted(table) << " WHERE id=" << id << ";";return oss.str();  // 自动处理SQL注入问题
}

 重复使用字符串流

ostringstream oss;
oss << "第一部分";
cout << oss.str();  // 输出"第一部分"oss.str("");       // 清空内容
oss << "新内容";   // 重新使用

 处理带引号的字符串

string input = "\"Hello, World!\" 42";
istringstream iss(input);
string text;
int num;iss >> quoted(text) >> num;  // text="Hello, World!", num=42

 二进制数据转换

vector<uint8_t> bytes = {0x48, 0x65, 0x6c, 0x6c, 0x6f};
ostringstream oss;
oss.write(reinterpret_cast<char*>(bytes.data()), bytes.size());
string binary_str = oss.str();

---

8. 注意事项

• 状态管理：多次使用同一个流时需要调用clear()和str("")

• 错误处理：检查流状态是否有效

if (!(iss >> value)) {std::cerr << "格式错误！";
}

• 性能：频繁创建流对象会影响性能，可复用对象

9.性能优化

1. 预分配缓冲区

ostringstream oss;
oss.rdbuf()->pubsetbuf(nullptr, 1024);  // 预分配1KB缓冲区

2. 减少临时对象

// 低效方式
string s1 = oss1.str() + oss2.str();// 高效方式
ostringstream final;
final << oss1.rdbuf() << oss2.rdbuf();
string result = final.str();

 十二、扩展与自定义

1. 重载操作符实现自定义类型IO

struct Vec3 {float x, y, z;friend ostream& operator<<(ostream& os, const Vec3& v) {return os << "[" << v.x << "," << v.y << "," << v.z << "]";}friend istream& operator>>(istream& is, Vec3& v) {char dummy;return is >> dummy >> v.x >> dummy >> v.y >> dummy >> v.z >> dummy;}
};// 使用示例
Vec3 v;
cin >> v;  // 输入格式示例：[1,2,3]
cout << v; // 输出：[1,2,3]

2. 创建自定义流

class TeeStream : public ostream {ostream& stream1;ostream& stream2;TeeStream(ostream& s1, ostream& s2) : ostream(s1.rdbuf()), stream1(s1), stream2(s2) {}TeeStream& operator<<(ostream& (*manip)(ostream&)) {stream1 << manip;stream2 << manip;return *this;}// 需要重载其他<<操作符...
};// 同时输出到控制台和文件
ofstream logfile("log.txt");
TeeStream mycout(cout, logfile);
mycout << "同时输出到两个目标" << endl;

---