Kembalikan status std :: cout setelah memanipulasinya

Misalkan saya memiliki kode seperti ini:

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

Pertanyaan saya adalah apakah ada cara untuk 'mengembalikan' keadaan coutke semula setelah kembali dari fungsi? (Agak suka std::boolalphadan std::noboolalpha..)?

Terima kasih.

Anda perlu #include <iostream>atau #include <ios>saat diminta:

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

//Your code here...

cout.flags( f );

Anda dapat meletakkan ini di awal dan akhir fungsi Anda, atau lihat jawaban tentang cara menggunakan ini dengan RAII .

The Meningkatkan IO Streaming Negara Saver tampaknya apa yang Anda butuhkan. :-)

Contoh berdasarkan cuplikan kode Anda:

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

Perhatikan bahwa jawaban yang disajikan di sini tidak akan memulihkan keadaan penuh std::cout. Misalnya, std::setfillakan "tetap" bahkan setelah menelepon .flags(). Solusi yang lebih baik adalah dengan menggunakan .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;

Akan mencetak:

case closed

daripada:

case closed0000

Saya telah membuat kelas RAII menggunakan kode contoh dari jawaban ini. Keuntungan besar dari teknik ini datang jika Anda memiliki beberapa jalur pengembalian dari fungsi yang menyetel bendera pada iostream. Jalur pengembalian mana pun yang digunakan, destruktor akan selalu dipanggil dan bendera akan selalu disetel ulang. Tidak ada kemungkinan lupa untuk memulihkan bendera saat fungsi kembali.

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

Anda kemudian akan menggunakannya dengan membuat instance lokal IosFlagSaver kapan pun Anda ingin menyimpan status flag saat ini. Ketika instance ini keluar dari ruang lingkup, status bendera akan dipulihkan.

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

Dengan sedikit modifikasi untuk membuat keluarannya lebih mudah dibaca:

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

Anda dapat membuat pembungkus lain di sekitar buffer 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"
}

Dalam sebuah fungsi:

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

Tentu saja jika kinerja menjadi masalah, ini sedikit lebih mahal karena menyalin seluruh iosobjek (tetapi bukan buffer) termasuk beberapa hal yang Anda bayar tetapi tidak mungkin digunakan seperti lokal.

Kalau tidak, saya merasa jika Anda akan menggunakannya .flags()lebih baik untuk konsisten dan menggunakan .setf()juga daripada <<sintaks (pertanyaan murni tentang gaya).

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

Seperti yang dikatakan orang lain, Anda dapat meletakkan hal-hal di atas (dan .precision()dan .fill(), tetapi biasanya bukan lokal dan hal-hal yang berhubungan dengan kata-kata yang biasanya tidak akan dimodifikasi dan lebih berat) di dalam kelas untuk kenyamanan dan membuatnya aman untuk pengecualian; konstruktor harus menerima std::ios&.

Saya ingin menggeneralisasi jawaban dari 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_;
};

Ini harus berfungsi untuk aliran input dan lainnya juga.

PS: Saya ingin membuat ini hanya sebagai komentar untuk jawaban di atas, namun stackoverflow tidak mengizinkan saya melakukannya karena reputasi yang hilang. Jadi buat saya mengacaukan jawaban di sini daripada komentar sederhana ...