Drucken zero-padded hex mit std :: cout

Question

Angenommen, ich habe ein dword, das ich in hex ausgeben soll mit std :: cout und links-pad mit Nullen, so 0xabcd wird als 0x0000abcd angezeigt. Es scheint, wie Sie hätte dies tun:

uint32_t my_int = 0xabcd; 

std::cout << "0x" << std::hex << std::setw(8) << std::setfill('0') 
    << my_int << std::endl; 

Das für etwas lächerlich scheint, die mit printf("0x%08X\n", my_int); in C erreicht werden kann. Gibt es eine Möglichkeit, dies kürzer zu machen, während immer noch std :: cout für die Ausgabe verwendet wird (neben der Verwendung von Namespace std)?

Answer 1

Ich nehme an, Sie können eine "Stream-Manipulator" schreiben. Dies ist nützlich, wenn Sie mehrere Hex-Zahlen haben, die Sie in diesem Format drucken möchten. Dies ist eindeutig keine ideale Lösung, aber mit einem Wrapper-Typ können Sie Ihr eigenes "Format Flag" erstellen, um es umzuschalten. Weitere Informationen finden Sie unter Sticky custom stream manipulator.

#include <iostream> 
#include <iomanip> 

static int const index = std::ios_base::xalloc(); 

std::ostream& hexify(std::ostream& stream) { 
    stream.iword(index) = 1; 
    return stream; 
} 

std::ostream& nohexify(std::ostream& stream) { 
    stream.iword(index) = 0; 
    return stream; 
} 

struct WrapperType { 
    uint32_t _m; 
public: 
    WrapperType(uint32_t m) : _m(m) 
    { 
    } 

    uint32_t getm() const 
    { 
     return _m; 
    } 
}; 
std::ostream& operator<< (std::ostream& os, const WrapperType& t) { 
    if (os.iword(index)) 
     return os << "0x" << std::hex << std::setw(8) << std::setfill('0') << t.getm(); 
    else 
     return os << t.getm(); 
} 

int main() 
{ 
    WrapperType my_int{0xabcd}; 
    std::cout << hexify << my_int << my_int; 
    std::cout << nohexify << my_int; 
} 

Answer 2

Meine C++ ist rostig, aber wie wäre es mit Boost-Formatierung: http://www.boost.org/doc/libs/1_37_0/libs/format/index.html

Answer 3

Ich würde nicht die (globale) Fahnen eines Stroms ändern, nur einen Manipulator:

#include <iostream> 
#include <iomanip> 
#include <limits> 

template <typename T> 
struct Hex 
{ 
    // C++11: 
    // static constexpr int Width = (std::numeric_limits<T>::digits + 1)/4; 
    // Otherwise: 
    enum { Width = (std::numeric_limits<T>::digits + 1)/4 }; 
    const T& value; 
    const int width; 

    Hex(const T& value, int width = Width) 
    : value(value), width(width) 
    {} 

    void write(std::ostream& stream) const { 
     if(std::numeric_limits<T>::radix != 2) stream << value; 
     else { 
      std::ios_base::fmtflags flags = stream.setf(
       std::ios_base::hex, std::ios_base::basefield); 
      char fill = stream.fill('0'); 
      stream << "0x" << std::setw(width) << value; 
      stream.fill(fill); 
      stream.setf(flags, std::ios_base::basefield); 
     } 
    } 
}; 

template <typename T> 
inline Hex<T> hex(const T& value, int width = Hex<T>::Width) { 
    return Hex<T>(value, width); 
} 

template <typename T> 
inline std::ostream& operator << (std::ostream& stream, const Hex<T>& value) { 
    value.write(stream); 
    return stream; 
} 

int main() { 
    std::uint8_t u8 = 1; 
    std::uint16_t u16 = 1; 
    std::uint32_t u32 = 1; 
    std::cout << hex(unsigned(u8), 2) << ", " << hex(u16) << ", " << hex(u32) << '\n'; 
}