Восстановить состояние std :: cout после манипулирования им

Предположим, у меня есть такой код:

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..)?

Спасибо.

вам нужно #include <iostream>или #include <ios>тогда, когда потребуется:

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

//Your code here...

cout.flags( f );

Вы можете поместить их в начало и конец своей функции или посмотреть этот ответ о том, как использовать это с RAII .

Функция Boost IO Stream State Saver кажется именно тем, что вам нужно. :-)

Пример на основе вашего фрагмента кода:

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

Обратите внимание, что ответы, представленные здесь, не восстановят полное состояние std::cout. Например, std::setfillбудет «прилипать» даже после звонка .flags(). Лучшее решение - использовать .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

Я создал класс 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;
}

С небольшими изменениями, чтобы сделать вывод более читабельным:

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

Вы можете создать другую оболочку вокруг буфера 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"
}

В функции:

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());
    os.setf(std::ios::hex);
    os << 123;
    os.flags(os_flags);
}

Как уже говорили другие, вы можете поместить вышеперечисленное (и .precision()и .fill(), но обычно не относящиеся к языку и словам вещи, которые обычно не будут изменены и тяжелее) в класс для удобства и для обеспечения безопасности исключений; конструктор должен принять std::ios&.

Я хотел бы несколько обобщить ответ qbert220:

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

Это должно работать и для входных потоков, и для других.

PS: Я бы хотел сделать это просто комментарием к приведенному выше ответу, однако stackoverflow не позволяет мне сделать это из-за отсутствия репутации. Так заставьте меня загромождать здесь ответы вместо простого комментария ...