Std :: cout durumunu işledikten sonra geri yükleyin

Şöyle bir kodum olduğunu varsayalım:

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

Sorum şu cout, işlevden döndükten sonra durumunu orijinal haline 'geri yüklemenin' herhangi bir yolu olup olmadığı ? (Biraz gibi std::boolalphave std::noboolalpha..)?

Teşekkürler.

yapmanız gereken #include <iostream>veya #include <ios>daha sonra gerektiğinde:

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

//Your code here...

cout.flags( f );

Bunları işlevinizin başına ve sonuna koyabilir veya bunu RAII ile nasıl kullanacağınıza dair bu yanıtı kontrol edebilirsiniz .

Boost IO Akış Devlet Tasarrufu tam olarak neye ihtiyacınız görünüyor. :-)

Kod pasajınıza dayalı örnek:

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

Burada sunulan yanıtların tam durumunu geri yüklemeyeceğini unutmayın std::cout. Örneğin, std::setfillaradıktan sonra bile "takılı kalacaktır" .flags(). Daha iyi bir çözüm kullanmaktır .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;

Yazdırılacak:

case closed

ziyade:

case closed0000

Bu yanıttaki örnek kodu kullanarak bir RAII sınıfı oluşturdum. Bu tekniğin en büyük avantajı, bir iostream'de bayrakları ayarlayan bir işlevden birden çok dönüş yolunuz varsa ortaya çıkar. Hangi dönüş yolu kullanılırsa kullanılsın, yıkıcı her zaman çağrılacak ve bayraklar her zaman sıfırlanacaktır. İşlev döndüğünde bayrakları geri yüklemeyi unutma şansı yoktur.

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

Daha sonra, mevcut bayrak durumunu kaydetmek istediğinizde yerel bir IosFlagSaver örneği oluşturarak onu kullanırsınız. Bu örnek kapsam dışına çıktığında bayrak durumu geri yüklenecektir.

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

Çıktıyı daha okunaklı hale getirmek için biraz değişiklik yaparak:

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 arabelleği etrafında başka bir sarmalayıcı oluşturabilirsiniz:

#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"
}

Bir işlevde:

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

Elbette, performans bir sorunsa, bu biraz daha pahalıdır, çünkü iosyerel ayar gibi para ödediğiniz ancak kullanamayacağınız bazı şeyler dahil olmak üzere tüm nesneyi (ancak arabelleği değil) kopyalamaktır .

Aksi takdirde, eğer .flags()kullanacaksanız .setf(), <<sözdizimi yerine tutarlı olmanın ve kullanmanın daha iyi olduğunu düşünüyorum (saf stil sorunu).

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

Diğerleri söylediler Yukarıdaki koymak (ve edebilir .precision()ve .fill()ancak tipik genellikle modifiye edilecek ve daha ağır değildir değil yerel ve kelimeler alakalı şeyler) bir sınıfta kolaylık ve özel durum korumalı hale getirmek için; kurucu kabul etmelidir std::ios&.

Qbert220'nin cevabını bir şekilde genellemek istiyorum:

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

Bu, giriş akışları ve diğerleri için de çalışmalıdır.

Not: Bunu yukarıdaki cevaba basitçe bir yorum yapmak isterdim, ancak stackoverflow eksik itibar nedeniyle bunu yapmama izin vermiyor. Bu yüzden basit bir yorum yerine cevapları burada karıştırıyorum ...