Відновити стан 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 .

Збільшення стану потоку введення-виведення IOS здається саме тим, що вам потрібно. :-)

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

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 не дозволяє мені це зробити через відсутність репутації. Таким чином, змушуйте мене чіпляти відповіді тут, а не простий коментар ...