Ripristina lo stato di std :: cout dopo averlo manipolato

Supponiamo che io abbia un codice come questo:

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

La mia domanda è se esiste un modo per "ripristinare" lo stato di coutquello originale dopo essere tornati dalla funzione? (Un po 'come std::boolalphaestd::noboolalpha ..)?

Grazie.

è necessario #include <iostream>o #include <ios>poi quando richiesto:

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

//Your code here...

cout.flags( f );

Puoi metterli all'inizio e alla fine della tua funzione, o dai un'occhiata a questa risposta su come usarlo con RAII .

Il Boost IO Stream State Saver sembra esattamente ciò di cui hai bisogno. :-)

Esempio basato sullo snippet di codice:

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

Nota che le risposte presentate qui non ripristineranno lo stato completo di std::cout. Ad esempio, std::setfill"rimarrà" anche dopo aver chiamato .flags(). Una soluzione migliore è usare .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;

Stamperà:

case closed

piuttosto che:

case closed0000

Ho creato una classe RAII usando il codice di esempio da questa risposta. Il grande vantaggio di questa tecnica si ha se si hanno più percorsi di ritorno da una funzione che imposta i flag su un iostream. Qualunque sia il percorso di ritorno utilizzato, il distruttore verrà sempre chiamato e i flag verranno sempre ripristinati. Non c'è possibilità di dimenticare di ripristinare i flag quando la funzione ritorna.

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

Dovresti quindi usarlo creando un'istanza locale di IosFlagSaver ogni volta che desideri salvare lo stato di flag corrente. Quando questa istanza esce dall'ambito, lo stato flag verrà ripristinato.

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

Con qualche modifica per rendere l'output più leggibile:

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

Puoi creare un altro wrapper attorno al 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"
}

In una funzione:

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

Ovviamente se le prestazioni sono un problema, questo è un po 'più costoso perché sta copiando l'intero ios oggetto (ma non il buffer) includendo alcune cose che stai pagando ma che è improbabile che tu usi come la locale.

Altrimenti penso che se hai intenzione di usarlo .flags()è meglio essere coerenti e usare .setf()anche piuttosto che la <<sintassi (pura questione di stile).

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

Come altri hanno già detto, puoi mettere quanto sopra (e .precision()e .fill(), ma in genere non il locale e le cose relative alle parole che di solito non verranno modificate ed è più pesante) in una classe per comodità e per renderla sicura rispetto alle eccezioni; il costruttore dovrebbe accettare std::ios&.

Vorrei generalizzare in qualche modo la risposta di 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_;
};

Questo dovrebbe funzionare anche per i flussi di input e altri.

PS: mi sarebbe piaciuto fare questo semplicemente un commento alla risposta sopra, stackoverflow tuttavia non mi consente di farlo a causa della mancanza di reputazione. Quindi fammi confondere le risposte qui invece di un semplice commento ...