C++ 的 Streams 的显式管理、主动重置状态_stringstream恢复格式-CSDN博客

在使用 C++ 的 Streams（如 std::cout）时，流的状态（如数字的进制、精度、填充字符等）是持久的。如果不主动重置状态，先前的设置会影响后续的输出。因此，显式管理流状态非常重要，以确保代码行为可预测。下面我将详细讲解如何主动重置状态，并提供示例。

流状态的常见修改

Streams 的状态可以通过流操纵器（manipulators）或成员函数修改。例如：

进制：std::hex（十六进制）、std::oct（八进制）、std::dec（十进制）。
浮点精度：std::precision() 或 std::setprecision()。
填充字符和宽度：std::fill() 和 std::setw()。
格式标志：std::fixed（固定小数）、std::scientific（科学计数法）等。

这些状态一旦设置，会一直保留，直到被显式修改。

如何显式管理状态

为了避免流状态的意外影响，可以在每次使用流时：

保存当前状态。
设置所需状态。
使用完后恢复原始状态。

以下是几种常见方法：

方法 1：使用 `std::ios::fmtflags` 保存和恢复状态

std::ios_base::fmtflags 是一个类型，用于保存流的格式标志状态。通过 flags() 成员函数，可以获取和设置整个状态。

#include <iostream>

void printNumber(int num) {
    // 保存当前状态
    std::ios_base::fmtflags oldFlags = std::cout.flags();
    
    // 设置新状态
    std::cout << std::hex << num << std::endl;
    
    // 恢复原始状态
    std::cout.flags(oldFlags);
}

int main() {
    std::cout << 10 << std::endl; // 输出 10（十进制，默认状态）
    printNumber(255);             // 输出 ff（十六进制）
    std::cout << 10 << std::endl; // 输出 10（十进制，状态已恢复）
    return 0;
}

std::cout.flags()：不带参数时返回当前标志，带参数时设置标志。
优点：一次性保存和恢复所有格式标志。
缺点：不能单独控制某个状态（如只恢复进制）。

方法 2：显式重置特定状态

如果你只关心某些特定状态（如进制），可以直接重置它们。例如，使用 std::dec 重置为十进制：

#include <iostream>

void printNumber(int num) {
    std::cout << std::hex << num << std::endl; // 设置为十六进制并输出
    std::cout << std::dec;                     // 显式重置为十进制
}

int main() {
    std::cout << 10 << std::endl; // 输出 10（十进制）
    printNumber(255);             // 输出 ff（十六进制）
    std::cout << 10 << std::endl; // 输出 10（十进制，状态已重置）
    return 0;
}

常见重置操纵器：
- 进制：std::dec（十进制）、std::hex（十六进制）、std::oct（八进制）。
- 浮点格式：std::defaultfloat（默认浮点格式，C++11 起支持）。
- 其他：std::noshowbase（取消进制前缀）、std::nouppercase（小写字母）等。
优点：简单直接，适合只需要调整少量状态的场景。
缺点：需要手动跟踪和管理所有可能更改的状态。

方法 3：使用 `std::stringstream` 隔离状态

如果不想影响全局流（如 std::cout），可以使用临时的 std::stringstream，它的状态是独立的：

#include <iostream>
#include <sstream>

void printNumber(int num) {
    std::stringstream ss;
    ss << std::hex << num;           // 设置十六进制，状态仅影响 ss
    std::cout << ss.str() << std::endl; // 输出到 cout，不影响 cout 的状态
}

int main() {
    std::cout << 10 << std::endl; // 输出 10（十进制）
    printNumber(255);             // 输出 ff（十六进制）
    std::cout << 10 << std::endl; // 输出 10（十进制，cout 状态未变）
    return 0;
}

优点：完全隔离状态，不影响其他流。
缺点：需要额外的对象，性能开销稍高。

方法 4：使用 RAII 封装状态管理

为了更优雅地管理状态，可以用 RAII（资源获取即初始化）封装流的保存和恢复：

#include <iostream>

class StreamStateGuard {
public:
    explicit StreamStateGuard(std::ostream& os) : os_(os) {
        oldFlags_ = os_.flags(); // 保存状态
    }
    ~StreamStateGuard() {
        os_.flags(oldFlags_);    // 自动恢复状态
    }
private:
    std::ostream& os_;
    std::ios_base::fmtflags oldFlags_;
};

void printNumber(int num) {
    StreamStateGuard guard(std::cout); // RAII 对象
    std::cout << std::hex << num << std::endl; // 修改状态
    // 函数退出时，guard 析构，状态自动恢复
}

int main() {
    std::cout << 10 << std::endl; // 输出 10（十进制）
    printNumber(255);             // 输出 ff（十六进制）
    std::cout << 10 << std::endl; // 输出 10（十进制，状态已恢复）
    return 0;
}

优点：自动管理状态，避免遗漏；异常安全。
缺点：需要额外定义类，代码稍复杂。

综合示例：显式管理多种状态

假设你需要同时控制进制、精度和填充字符：

#include <iostream>
#include <iomanip>

void printFormatted(double num) {
    // 保存状态
    std::ios_base::fmtflags oldFlags = std::cout.flags();
    char oldFill = std::cout.fill();
    std::streamsize oldPrecision = std::cout.precision();

    // 设置新状态
    std::cout << std::hex << std::setprecision(2) << std::setw(10) << std::setfill('0') << num << std::endl;

    // 恢复状态
    std::cout.flags(oldFlags);
    std::cout.fill(oldFill);
    std::cout.precision(oldPrecision);
}

int main() {
    std::cout << 123.456 << std::endl; // 输出 123.456（默认状态）
    printFormatted(255.789);           // 输出 000000ff.c7（十六进制，填充 0，精度 2）
    std::cout << 123.456 << std::endl; // 输出 123.456（状态已恢复）
    return 0;
}