Khôi phục trạng thái của std :: cout sau khi thao tác với nó

Giả sử tôi có một đoạn mã như sau:

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..
}

Câu hỏi của tôi là liệu có cách nào để 'khôi phục' trạng thái về trạng thái coutban đầu sau khi trở về từ chức năng không? (Hơi giống std::boolalphavà std::noboolalpha..)?

Cảm ơn.

bạn cần #include <iostream>hoặc #include <ios>sau đó khi được yêu cầu:

std::ios_base::fmtflags f( cout.flags() );

//Your code here...

cout.flags( f );

Bạn có thể đặt chúng ở đầu và cuối hàm của mình hoặc xem câu trả lời này về cách sử dụng nó với RAII .

Các Boost IO Suối nước Saver dường như chính xác những gì bạn cần. :-)

Ví dụ dựa trên đoạn mã của bạn:

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

Lưu ý rằng các câu trả lời được trình bày ở đây sẽ không khôi phục trạng thái đầy đủ của std::cout. Ví dụ: std::setfillsẽ "dính" ngay cả sau khi gọi .flags(). Một giải pháp tốt hơn là sử dụng .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;

Sẽ in:

case closed

hơn là:

case closed0000

Tôi đã tạo một lớp RAII bằng cách sử dụng mã ví dụ từ câu trả lời này. Lợi thế lớn của kỹ thuật này là nếu bạn có nhiều đường dẫn trả về từ một hàm đặt cờ trên iostream. Cho dù sử dụng đường dẫn trả về nào, hàm hủy sẽ luôn được gọi và các cờ sẽ luôn được đặt lại. Không có khả năng quên khôi phục các cờ khi hàm trả về.

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

Sau đó, bạn sẽ sử dụng nó bằng cách tạo một phiên bản cục bộ của IosFlagSaver bất cứ khi nào bạn muốn lưu trạng thái cờ hiện tại. Khi trường hợp này vượt ra khỏi phạm vi, trạng thái cờ sẽ được khôi phục.

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

Với một chút sửa đổi để làm cho đầu ra dễ đọc hơn:

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..
}

Bạn có thể tạo một trình bao bọc khác xung quanh bộ đệm stdout:

#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"
}

Trong một hàm:

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

Tất nhiên nếu hiệu suất là một vấn đề, điều này sẽ đắt hơn một chút vì nó sao chép toàn bộ ios đối tượng (nhưng không phải bộ đệm) bao gồm một số thứ mà bạn đang trả tiền nhưng không có khả năng sử dụng như ngôn ngữ.

Nếu không, tôi cảm thấy nếu bạn định sử dụng .flags()thì tốt hơn là nên nhất quán và sử dụng .setf()tốt hơn là <<cú pháp (câu hỏi thuần túy về phong cách).

void print(std::ostream& os) {
    std::ios::fmtflags os_flags (os.flags());
    os.setf(std::ios::hex);
    os << 123;
    os.flags(os_flags);
}

Như những người khác đã nói, bạn có thể đặt những thứ ở trên (và .precision()và .fill(), nhưng thường không phải là ngôn ngữ và những thứ liên quan đến từ thường sẽ không được sửa đổi và nặng hơn) trong một lớp để thuận tiện và an toàn cho ngoại lệ; hàm tạo nên chấp nhận std::ios&.

Tôi muốn khái quát câu trả lời từ qbert220 phần nào:

#include <ios>

class IoStreamFlagsRestorer
{
public:
    IoStreamFlagsRestorer(std::ios_base & ioStream)
        : ioStream_(ioStream)
        , flags_(ioStream_.flags())
    {
    }

    ~IoStreamFlagsRestorer()
    {
        ioStream_.flags(flags_);
    }

private:
    std::ios_base & ioStream_;
    std::ios_base::fmtflags const flags_;
};

Điều này sẽ hoạt động cho các luồng đầu vào và những luồng khác.

Tái bút: Tôi muốn làm điều này chỉ đơn giản là một nhận xét cho câu trả lời ở trên, tuy nhiên stackoverflow không cho phép tôi làm như vậy vì thiếu danh tiếng. Vì vậy, làm cho tôi lộn xộn các câu trả lời ở đây thay vì một nhận xét đơn giản ...