恢复性病的状态::法院它

Question

假设我有这样的代码：

void printHex(std::ostream& x){ 
    x<<std::hex<<123; 
} 
.. 
int main(){ 
    std::cout<<100; // prints 100 base 10 
    printHex(std::cout); //prints 123 in hex 
    std::cout<<73; //problem! prints 73 in hex.. 
} 

我的问题是，如果有任何的方式来后COUT的状态“恢复”到原来的一个从函数返回？ （有点像std :: boolalpha和std :: noboolalpha ..）？

谢谢。

Answer 1

谷歌搜索给了我这个：

ios::fmtflags f(cout.flags()); 

    //Your code here... 

    cout.flags(f); 

你可能希望把他们在你的函数的开始和结束。

Answer 2

Boost IO Stream State Saver看起来正是你所需要的。 :-)

例如基于您的代码段：

void printHex(std::ostream& x) { 
    boost::io::ios_flags_saver ifs(x); 
    x << std::hex << 123; 
} 

Answer 3

随着修改一点点，使输出更具可读性：

void printHex(std::ostream& x) { 
    ios::fmtflags f(x.flags()); 
    x << std::hex << 123 << "\n"; 
    x.flags(f); 
} 

int main() { 
    std::cout << 100 << "\n"; // prints 100 base 10 
    printHex(std::cout);  // prints 123 in hex 
    std::cout << 73 << "\n"; // problem! prints 73 in hex.. 
} 

Answer 4

我使用示例代码从这个答案创建了一个RAII类。如果你在一个设置iostream标志的函数中有多个返回路径，这种技术的最大优点就来了。无论使用哪条返回路径，析构函数将始终被调用，并且标志将始终得到重置。当函数返回时，不会忘记恢复标志。

class IosFlagSaver { 
public: 
    explicit IosFlagSaver(std::ostream& _ios): 
     ios(_ios), 
     f(_ios.flags()) { 
    } 
    ~IosFlagSaver() { 
     ios.flags(f); 
    } 

    IosFlagSaver(const IosFlagSaver &rhs) = delete; 
    IosFlagSaver& operator= (const IosFlagSaver& rhs) = delete; 

private: 
    std::ostream& ios; 
    std::ios::fmtflags f; 
}; 

您将通过创建IosFlagSaver的本地实例，每当你想保存当前位状态，然后使用它。当这个实例超出范围时，标志状态将被恢复。

void f(int i) { 
    IosFlagSaver iosfs(std::cout); 

    std::cout << i << " " << std::hex << i << " "; 
    if (i < 100) { 
     std::cout << std::endl; 
     return; 
    } 
    std::cout << std::oct << i << std::endl; 
} 

Answer 5

请注意，此处显示的答案不会恢复std::cout的完整状态。例如，即使在致电.flags()后，std::setfill也会“粘住”。一个更好的解决方案是使用.copyfmt：

std::ios oldState(nullptr); 
oldState.copyfmt(std::cout); 

std::cout 
    << std::hex 
    << std::setw(8) 
    << std::setfill('0') 
    << 0xDECEA5ED 
    << std::endl; 

std::cout.copyfmt(oldState); 

std::cout 
    << std::setw(15) 
    << std::left 
    << "case closed" 
    << std::endl; 

会打印：

case closed 

而不是：

case closed0000 

Answer 6

就可以围绕标准输出缓冲区中的另一包装：

#include <iostream> 
#include <iomanip> 
int main() { 
    int x = 76; 
    std::ostream hexcout (std::cout.rdbuf()); 
    hexcout << std::hex; 
    std::cout << x << "\n"; // still "76" 
    hexcout << x << "\n"; // "4c" 
} 

在func重刑：

void print(std::ostream& os) { 
    std::ostream copy (os.rdbuf()); 
    copy << std::hex; 
    copy << 123; 
} 

当然，如果性能是一个问题，这是一个有点贵，因为它是复制整个ios对象（但不包括缓冲区）在内的一些东西，你付出的，但不太可能使用如语言环境。

否则我觉得如果你打算使用.flags()，最好保持一致并使用.setf()而不是<<语法（风格的纯粹问题）。

void print(std::ostream& os) { 
    std::ios::fmtflags os_flags (os.flags()); 
    std::size_t os_width (os.width()); 
    os.setf(std::ios::hex); 
    os.width(4); 

    os << 123; 

    os.flags(os_flags); 
    os.width(os_width); 
} 

正如其他人说你可以把上面的（和.precision()和.fill()，但通常没有语言环境和单词相关的东西，通常不会被修改，并且较重）一类为方便和使其异常安全;构造函数应该接受std::ios&。