Przywróć stan std :: cout po manipulowaniu nim

Załóżmy, że mam taki kod:

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

Moje pytanie brzmi, czy istnieje sposób „przywrócenia” stanu coutpierwotnego po powrocie z funkcji? (Trochę jak std::boolalphai std::noboolalpha...)?

Dzięki.

musisz #include <iostream>lub #include <ios>wtedy w razie potrzeby:

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

//Your code here...

cout.flags( f );

Możesz umieścić je na początku i na końcu swojej funkcji lub sprawdzić tę odpowiedź, jak używać tego z RAII .

Doładowania IO Stream państwo oszczędzania wydaje się dokładnie to, czego potrzebują. :-)

Przykład na podstawie fragmentu kodu:

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

Zwróć uwagę, że przedstawione tutaj odpowiedzi nie przywrócą pełnego stanu std::cout. Na przykład std::setfillbędzie się „trzymać” nawet po sprawdzeniu .flags(). Lepszym rozwiązaniem jest użycie .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;

Wydrukuje:

case closed

zamiast:

case closed0000

Utworzyłem klasę RAII, używając przykładowego kodu z tej odpowiedzi. Dużą zaletą tej techniki jest sytuacja, gdy masz wiele ścieżek powrotu z funkcji, która ustawia flagi w iostream. Niezależnie od używanej ścieżki powrotnej, destruktor będzie zawsze wywoływany, a flagi zawsze będą resetowane. Nie można zapomnieć o przywróceniu flag, gdy funkcja powróci.

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

Można go następnie użyć, tworząc lokalną instancję IosFlagSaver, ilekroć chcesz zapisać bieżący stan flagi. Gdy to wystąpienie znajdzie się poza zakresem, stan bandery zostanie przywrócony.

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

Z niewielkimi modyfikacjami, aby wynik był bardziej czytelny:

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

Możesz utworzyć inną otokę wokół bufora 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"
}

W funkcji:

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

Oczywiście, jeśli problemem jest wydajność, jest to trochę droższe, ponieważ polega na kopiowaniu całego iosobiektu (ale nie bufora), w tym niektórych rzeczy, za które płacisz, ale prawdopodobnie nie używasz, takich jak ustawienia regionalne.

W przeciwnym razie czuję, że jeśli zamierzasz używać .flags(), lepiej być konsekwentnym i używać .setf()również zamiast <<składni (czysta kwestia stylu).

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

Jak powiedzieli inni, możesz umieścić powyższe (i .precision()i .fill(), ale zwykle nie dotyczy to ustawień regionalnych i słów, które zwykle nie będą modyfikowane i są cięższe) w klasie dla wygody i aby były bezpieczne; konstruktor powinien zaakceptować std::ios&.

Chciałbym nieco uogólnić odpowiedź z 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_;
};

Powinno to działać również w przypadku strumieni wejściowych i innych.

PS: Chciałbym to zrobić po prostu jako komentarz do powyższej odpowiedzi, jednak stackoverflow nie pozwala mi na to z powodu braku reputacji. W ten sposób zaśmiecę tutaj odpowiedzi zamiast prostego komentarza ...