第 7 章笔记

• IOstream 把输入输出视作字节流（流式IO）
• 可以在其基础上构建记录 IO

• 表示形式的变化：使用格式化 / 解析将数据内部的表示（二级制）转化为字符序列（或反向转换，比如 std::cin）
• 与外部设备的通信：对于不同的外部设备（IOstream 指定的外部设备：比如终端，文件，内存）等会有不同的处理逻辑

int x = 100;
// 通过格式化的方式，将二进制的形式转换成了相应的字符序列的表示
std::cout << x << std::endl;

// 使用一块内存
// 用于保存 x 或者 y
union 
{
   int x;
   float y;
};
x = 100;

// 使用不同的方式去解析同一内存中的内容
// float 与 int 的解析方式不同
std::cout << x << std::endl;

std::cout << y << std::endl;

• 格式化 / 解析：将内容转化为字节序列 / 将字节序列转化为内容
• 缓存：将要输出的内容置于缓存中，在缓存将满的时候一次性输出
• 编码转换：比如 UTF8 到 GB（转换字符所占内存的表示）
• 传输：从缓存中逐一进行读取

• std::basic_stream：
  • 封装设备特性：通过不断的继承，在每一步的继承中实现不同设备的输出
  • 封装字符特性：使用类模板中的参数，通过替换该参数实现不同的流（比如使用 std::basic_ifstream<char> 处理 char 类型字符）
  • 实际上是类模板实例化的结果

• 输入输出分为格式化和非格式化两类

• 输入：get / read/ getline / gcount
• 输出： put / write
• 特点：对计算机（性能）友好，不会通过格式化来改变内容的长度（比如输出 float 就只会最多输出 4个字节的内容）

int x;
//对指定地址的内容的字符进行读取
//不解析，直接放入 x
//一共读取 4个字符 100加上回车，对应的就是每个字符的 ascii 值
//注意：read 要求 4个字符，在没有满足条件之前，系统会一直等待用户输入
std::cin.read(reinterpret_cast<char*>(&x), sizeof(x));

• 使用移位操作符 » 和 « 的重载来输入输出
• 特点：对人友好，根据不同的类型（内建，自定义）进行重载，输出不同的格式：

char c = '0';
// 针对 char 输出字符 0
std::cout << c << std::endl;

// 针对 Int 输出 ascii 48
int ci = static_cast<int>(c);
std::cout << ci << std::endl;

• 位掩码类型：showpos，改变的是格式化的行为

char c = '0';
// 显示正负，输出 +48
// 只对数值产生影响
std::cout.setf(std::ios_base::showpos);

• 取值随意的格式化参数：width()

// 让输出占10个字符，默认往左边加空格
// 默认只生效一次，读取后会被 reset 为 0
std::cout.width(10);

• 填充字符 fill

// 使用 * 占位
std::cout.fill('*');

• manipulator：允许直接在输入输出流中使用格式控制：

// 等同与之前的 showpos 用法，输出 +48
// witdh 的替换，需要使用 iomanip 头文件，使用 setw()
// fill 的替换，使用 setfill()
std::cout << std::showpos << std::setw(10) << std::setfill('*') << ci << std::endl;

• std::endl

• 具有提取操作：
  • 会放松对提取的类型限制：比如使用 std::cin 时，空格+10，+10，+010 都会被提取为 10
  • 提取操作有限制（某些信息不能智能进行提取）

char y[5];
// 输入长度超过 4字节 (4+\0) 均会导致内存越界
// std::string 存在缓存机制，不受限制
std::cin >> y;

// 使用 setw() 控制输入的长度，提取前 4 个字符
std::cin >> std::setw(5) >> y;

• basic_ifstream / basic_ofstream / basic_fstream：别名 i/f stream，类模板，流中单位为 char
• 输入 / 输出 / 同时打开输入输出

// 传入参数为文件名
// 输出流
std::ofstream outFile("test_file");
// 输出到文件 test_file
outFile << "hello";

// 输入流
std::ifstream inFile("test_file");
std::string x;
inFile >> x;
std::cout << x << std::endl;

• 检测状态 std::basic_ostream::isopen()
• 打开文件，关联流：outFile.open(“test_file”);
• 关闭文件，关闭流：outFIle.close();

• 每次读取写入都会非常消耗资源
• 系统会将缓存内的东西积累起来，在关闭流时写入文件
• 未显示关闭文件流时，ostream 的析构函数会在析构其对象时自动销毁
• 可以使用域控制 ostream 对象的生存周期，使用其析构函数自动关闭文件流

{
    // outFile 会在大括号之后自动关闭流
    std::ostream outFile.open("test_file");
}

上述的打开方式都是以二进制的形态设计的，其中每一种打开方式占一位。如果组合使用，则是以两种方式的按位或运算进行：

// in & ate
// 按位 或进行组合
std::ios_base::in;   // 0010
std::ios_base::ate; // 0001
// 得到 0011，在文件末尾进行读写

• 用于控制文件读取 / 写入的起始位置
• in / out 默认起始为文件开始的位置

• 写入，并删除之前文件内的内容

// 将文件中的 hello 替代为 word
std::ofstream outFile("test_file", std::ios_base::out | std::ios_base::trunc);
outFile << "word";

• 可以禁止系统内定的转换

都定义于 <sstream> 中：

• basic_istringstream：读
• basic_ostringstream：写
• basic_stringstream：读写
• 处理类型单位默认为 char，也受打开模式的影响(in/out/ate/app)

• 注意格式化输出会将输入转化为字符串：

int main(int argc, char const *argv[])
{
    std::ostringstream myObj;
    // 写入内容到流 (整数)
    // 转换整数到字符串（格式化）
    myObj << 1234;
    // 获取 myObj 所对应内存，使用配套的 str() 返回内容（字符串）
    std::string ret = myObj.str();

    std::cout << ret << std::endl;
    //读取字符串，并格式化（转换字符串为 int）
    std::istringstream myObj2(ret);   
    int x;  
    //将 int 赋值给 x 并打印
    myObj2 >> x;
    std::cout << x << std::endl;
    return 0;
}

// 默认的模式是从起始位置开始替换

// 默认输出流中的内容是 test
// 所有输出都会基于 test 输出
std::ostringstream myObj3("test", std::ios_base::ate);
myObj3 << '1';

// 打印结果为 test1
// stringstream 会自动管理内存
std::cout << myObj3.str();

• 返回 std::string
• 不要间接使用 str().c_str() 将字符串转换为 C 风格的字符串：该行为未定义
  • str() 返回的是右值
  • c_str() 指向了返回右值的内部的首地址，由于返回的是临时值，所以该访问未定义

// 类似 vector 的空间申请
// 可能每次都会进行 allocate
std::string s;
s += "hello";
s += "world";
s += "hello";

// 改良
// 利用 ostringstream 的大缓存进行拼接
// 不会频繁的 allocate
std::ostringstream word;
word << "hello";
word << "world";
word << "hello";

// 结果相同
std::cout << s;
std::cout << word.str();

• 提供额外的信息，使使用者针对状态进行对应的操作
• 使用 std::io_base::iostate 维护状态
• 非正常的状态的值都不是 0，几种错误可以同时出现（通过 bit 之间的按位或, BitMaskType）

• badbit：不可恢复的流错误（比如读写未关联的流）
• failbit：可恢复的流错误：读 / 写类型不匹配且无法转换（格式化错误），双重关闭一个流
• eofbit：输入序列达到了文件尾部

bit 的组合与返回结果的关系

// 使用 cin 的成员检测
std::cout << std::cin.good() 
          << std::cin.fail()
          << std::cin.bad()
          << std::cin.eof();
// 转换为 bool 值检测
          <<static_cast<bool>(std::cin) << std::endl;

• fail 和 eof 可能会被同时设置，但意义不同
• 转换为 bool 值时不会考虑 eof

// 判断之前的输入提取是否成功
if(std::cin >> x) { //}

• clear() ：设置当前流的指定状态（默认为 goodbit）
• setstate()：将某个状态附加到指定流上，

std::cin.clear();

• 可以通过 exception() 捕获流的异常

提取写入时，需要考虑提取写入的位置（定位）。C++ 为此引入了流的定位：

• 获取流
• 设置流

• tellg()：获取输入流中，接下来要读取的字符的位置
• tellp()：获取输出流中，当前可以写入的位置（读的是 white space）
• 两者返回一个为整数的 pos_type 类型。获取失败时，返回 pos_type(-1)
  • fail() == true 时

• seekg() / seep()：用于设置输入 / 输出流（覆盖输出）

• 设置绝对位置：接收 pos_type 的版本
• 设置相对位置：接收基本位置（beg,end,cur）+ 位移

系统默认的 “缓冲区满再输入到设备的” 行为很可能带来一些问题：

// 如果 some test 所在流没有满，导致没有被输出到终端
std::cout << "some test";
std::string name;
// 导致输入时没有提示
std::cin >> name;

• flush()：输出流同步，刷新缓冲区

// 成员调用
std::cout.flush();
// 操纵符
std::cout << x << std::flush;

• sync()：输入流同步，实现由编译器定义
  • 同文件同时关联了输入输出流，要对输入流刷新，得到输出流的信息
  • 具体行为与编译器实现有关系
• std::unitbuf：
  • 行为：大于一个字符的流必须被清除出缓存区
  • 结果：自动立即刷新（影响性能）
  • 通常与 std::cerr （标准错误输出）联用，因为错误信息必须及时更新

C++ 中，任意流都可以绑定到一个输出流上。当绑定时，绑定流会记录被绑定流中的信息。当绑定时：

• 绑定流在每次输入（输出）时，都会刷新被绑定流的缓冲区
• 绑定流可以同时与多个输出流绑定

这种方法实际上从另外的角度解决了之前提到过的问题：

// 如果 some test 所在流没有满，导致没有被输出到终端
std::cout << "some test";
std::string name;
// 导致输入时没有提示
std::cin >> name;

• 缺省情况下会与 C 同步
• 可以通过 sync_with_stdio 关闭同步