pantalla - salto de linea en c++

¿Cómo puedo imprimir 0x0a en lugar de 0xa usando cout? (7)

Esto funciona para mí en GCC:

#include <iostream> #include <iomanip> using namespace std; int main() { cout << "0x" << setfill(''0'') << setw(2) << hex << 10 << endl; }

Si te estás cansando de la peculiaridad de formateo de iostream, Boost.Format una oportunidad a Boost.Format . Permite predefinir el formato de estilo de impresión a la antigua, pero es seguro para el tipo de letra.

#include <iostream> #include <boost/format.hpp> int main() { std::cout << boost::format("0x%02x/n") % 10; }

¿Cómo puedo imprimir 0x0a, en lugar de 0xa usando cout?

#include <iostream> using std::cout; using std::endl; using std::hex; int main() { cout << hex << showbase << 10 << endl; }

Imprima cualquier número en hexadecimal con auto-relleno ''0'' o set. La plantilla permite cualquier tipo de datos (por ejemplo, uint8_t)

template<typename T, typename baseT=uint32_t> struct tohex_t { T num_; uint32_t width_; bool showbase_; tohex_t(T num, bool showbase = false, uint32_t width = 0) { num_ = num; showbase_ = showbase; width_ = width; } friend std::ostream& operator<< (std::ostream& stream, const tohex_t& num) { uint32_t w; baseT val; if (num.showbase_) stream << "0x"; if (num.width_ == 0) { w = 0; val = static_cast<baseT>(num.num_); do { w += 2; val = val >> 8; } while (val > 0); } else { w = num.width_; } stream << std::hex << std::setfill(''0'') << std::setw(w) << static_cast<baseT>(num.num_); return stream; } }; template<typename T> tohex_t<T> TO_HEX(T const &num, bool showbase = false, uint32_t width = 0) { return tohex_t<T>(num, showbase, width); }

Ejemplo:

std::stringstream sstr; uint8_t ch = 91; sstr << TO_HEX(5) << '','' << TO_HEX(ch) << '','' << TO_HEX(''0'') << std::endl; sstr << TO_HEX(1, true, 4) << '','' << TO_HEX(15) << '','' << TO_HEX(-1) << '',''; sstr << TO_HEX(513) << '','' << TO_HEX((1 << 16) + 3, true); std::cout << sstr.str();

Salida:

05,5b,30 0x0001,0f,ffffffff,0201,0x010003

Lo importante que falta en la respuesta es que debe usar a la right con todos los indicadores mencionados anteriormente:

cout<<"0x"<<hex<<setfill(''0'')<<setw(2)<<right<<10;

Para acortar las cosas para dar salida a hexadecimal, hice una macro simple

#define PADHEX(width, val) setfill(''0'') << setw(width) << std::hex << (unsigned)val

entonces

cout << "0x" << PADHEX(2, num) << endl;

Si desea facilitar la salida de un número hexadecimal, podría escribir una función como esta:

^{La versión actualizada se presenta a continuación;} ^{hay dos formas en que se puede insertar el indicador de base 0x , con notas al pie que detallan las diferencias entre ellos.} ^{La versión original se conserva en la parte inferior de la respuesta, para no molestar a nadie que la esté usando.}

^{Tenga en cuenta que tanto las versiones actualizadas como las originales pueden necesitar alguna adaptación para los sistemas en los que el tamaño del byte es un múltiplo de 9 bits.}

namespace detail { constexpr int HEX_DIGIT_BITS = 4; //constexpr int HEX_BASE_CHARS = 2; // Optional. See footnote #2. // Replaced CharCheck with a much simpler trait. template<typename T> struct is_char : std::integral_constant<bool, std::is_same<T, char>::value || std::is_same<T, signed char>::value || std::is_same<T, unsigned char>::value> {}; } template<typename T> std::string hex_out_s(T val) { using namespace detail; std::stringstream sformatter; sformatter << std::hex << std::internal << "0x" // See footnote #1. << std::setfill(''0'') << std::setw(sizeof(T) * CHAR_BIT / HEX_DIGIT_BITS) // See footnote #2. << (is_char<T>::value ? static_cast<int>(val) : val); return sformatter.str(); }

Se puede usar de la siguiente manera:

uint32_t hexU32 = 0x0f; int hexI = 0x3c; unsigned short hexUS = 0x12; std::cout << "uint32_t: " << hex_out_s(hexU32) << ''/n'' << "int: " << hex_out_s(hexI) << ''/n'' << "unsigned short: " << hex_out_s(hexUS) << std::endl;

Vea ambas opciones (como se detalla en las notas a pie de página, a continuación) en vivo: here .

Notas al pie:

Esta línea es responsable de mostrar la base, y puede ser una de las siguientes:
<< "0x" << std::showbase
- La primera opción se mostrará incorrectamente para los tipos personalizados que intentan generar números hexadecimales negativos como -0x## lugar de como <complement of 0x##> , con el signo que se muestra después de la base (como 0x-## ) en lugar de antes . Esto rara vez es un problema, por lo que personalmente prefiero esta opción.
  ^{Si esto es un problema, al usar estos tipos, puede verificar la negatividad antes de generar la base, y luego usar abs() (o un abs() personalizado abs() que devuelve un valor sin signo , si necesita poder manejar la mayor parte -valores negativos en un sistema de complemento de 2) en val .}
- La segunda opción omitirá la base cuando val == 0 , mostrando (por ejemplo, para int , donde int es 32 bits) 0000000000 lugar del esperado 0x00000000 . Esto se debe a que la bandera de la base de showbase se trata como # modificador # printf() internamente.
  ^{Si esto es un problema, puede verificar si val == 0 y aplicar un manejo especial cuando lo haga.}
Dependiendo de la opción elegida para mostrar la base, será necesario cambiar dos líneas.
- Si usa << "0x" , entonces HEX_BASE_CHARS es necesario, y puede omitirse.
- Si usa << std::showbase , entonces el valor proporcionado a setw() necesita tener en cuenta esto:
  << std::setw((sizeof(T) * CHAR_BIT / HEX_DIGIT_BITS) + HEX_BASE_CHARS)

La versión original es la siguiente:

// Helper structs and constants for hex_out_s(). namespace hex_out_helper { constexpr int HEX_DIGIT_BITS = 4; // One hex digit = 4 bits. constexpr int HEX_BASE_CHARS = 2; // For the "0x". template<typename T> struct CharCheck { using type = T; }; template<> struct CharCheck<signed char> { using type = char; }; template<> struct CharCheck<unsigned char> { using type = char; }; template<typename T> using CharChecker = typename CharCheck<T>::type; } // namespace hex_out_helper template<typename T> std::string hex_out_s(T val) { using namespace hex_out_helper; std::stringstream sformatter; sformatter << std::hex << std::internal << std::showbase << std::setfill(''0'') << std::setw((sizeof(T) * CHAR_BIT / HEX_DIGIT_BITS) + HEX_BASE_CHARS) << (std::is_same<CharChecker<T>, char>{} ? static_cast<int>(val) : val); return sformatter.str(); }

Que luego se puede usar así:

uint32_t hexU32 = 0x0f; int hexI = 0x3c; unsigned short hexUS = 0x12; std::cout << hex_out_s(hexU32) << std::endl; std::cout << hex_out_s(hexI) << std::endl; std::cout << "And let''s not forget " << hex_out_s(hexUS) << std::endl;

Ejemplo de trabajo: here .

Use setw y setfill desde iomanip

#include <iostream> #include <iomanip> using std::cout; using std::endl; using std::hex; int main() { cout << "0x" << std::setfill(''0'') << std::setw(2) << hex << 10 << endl; }

Personalmente, la naturaleza con estado de iostreams siempre me molesta. Creo que el formato de impulso es una mejor opción, así que recomendé la otra respuesta.

intenta esto ... simplemente antepones ceros según la magnitud.

cout << hex << "0x" << ((c<16)?"0":"") << (static_cast<unsigned int>(c) & 0xFF) << "h" << endl;

Puede modificar esto fácilmente para trabajar con números más grandes.

cout << hex << "0x"; cout << ((c<16)?"0":"") << ((c<256)?"0":""); cout << (static_cast<unsigned int>(c) & 0xFFF) << "h" << endl;

El factor es 16 (por un dígito hexadecimal):
16, 256, 4096, 65536, 1048576, ..
respectivo
0x10, 0x100, 0x1000, 0x10000, 0x100000, ..

Por lo tanto, también podrías escribir así ...

cout << hex << "0x" << ((c<0x10)?"0":"") << ((c<0x100)?"0":"") << ((c<0x1000)?"0":"") << (static_cast<unsigned int>(c) & 0xFFFF) << "h" << endl;

Y así sucesivamente ..: P