Stellen Sie den Status von std :: cout wieder her, nachdem Sie ihn bearbeitet haben

Angenommen, ich habe einen Code wie diesen:

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

Meine Frage ist, ob es eine Möglichkeit gibt cout, den ursprünglichen Zustand nach der Rückkehr von der Funktion wiederherzustellen . (Etwas wie std::boolalphaund std::noboolalpha..)?

Vielen Dank.

Sie müssen #include <iostream>oder #include <ios>dann, wenn erforderlich:

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

//Your code here...

cout.flags( f );

Sie können diese an den Anfang und das Ende Ihrer Funktion setzen oder diese Antwort zur Verwendung mit RAII lesen .

Der Boost IO Stream State Saver scheint genau das zu sein, was Sie brauchen. :-)

Beispiel basierend auf Ihrem Code-Snippet:

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

Beachten Sie, dass die hier dargestellten Antworten nicht den vollständigen Status von wiederherstellen std::cout. Zum Beispiel std::setfillbleibt auch nach dem Anruf "hängen" .flags(). Eine bessere Lösung ist zu verwenden .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;

Wird drucken:

case closed

eher, als:

case closed0000

Ich habe eine RAII-Klasse mit dem Beispielcode aus dieser Antwort erstellt. Der große Vorteil dieser Technik besteht darin, dass Sie mehrere Rückgabepfade von einer Funktion haben, die Flags in einem Iostream setzt. Unabhängig davon, welcher Rückweg verwendet wird, wird der Destruktor immer aufgerufen und die Flags werden immer zurückgesetzt. Es besteht keine Chance zu vergessen, die Flags wiederherzustellen, wenn die Funktion zurückkehrt.

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

Sie würden es dann verwenden, indem Sie eine lokale Instanz von IosFlagSaver erstellen, wann immer Sie den aktuellen Flag-Status speichern möchten. Wenn diese Instanz den Gültigkeitsbereich verlässt, wird der Flag-Status wiederhergestellt.

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

Mit ein wenig Modifikation, um die Ausgabe besser lesbar zu machen:

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

Sie können einen weiteren Wrapper um den Standardpuffer erstellen:

#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 einer Funktion:

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

Wenn die Leistung ein Problem darstellt, ist dies natürlich etwas teurer, da das gesamte iosObjekt (aber nicht der Puffer) kopiert wird, einschließlich einiger Dinge, für die Sie bezahlen, die Sie jedoch wahrscheinlich nicht verwenden werden, wie z. B. das Gebietsschema.

Ansonsten denke ich, wenn Sie es verwenden wollen, ist .flags()es besser, konsistent zu sein und es auch zu verwenden, .setf()als die <<Syntax (reine Frage des Stils).

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

Wie andere gesagt haben, können Sie die oben genannten (und .precision()und .fill(), aber normalerweise nicht das Gebietsschema und wortbezogene Dinge, die normalerweise nicht geändert werden und schwerer sind) in eine Klasse einordnen, um sie zu vereinfachen und ausnahmsicher zu machen. Der Konstruktor sollte akzeptieren std::ios&.

Ich möchte die Antwort von qbert220 etwas verallgemeinern:

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

Dies sollte auch für Eingabestreams und andere funktionieren.

PS: Ich hätte dies gerne einfach als Kommentar zur obigen Antwort gemacht. Der Stackoverflow erlaubt mir dies jedoch nicht, da der Ruf fehlt. Lassen Sie mich daher die Antworten hier anstelle eines einfachen Kommentars durcheinander bringen ...