Как напечатать unsigned char как hex в С++ с помощью ostream?

Ответ 1

Я бы предложил использовать следующую технику:

struct HexCharStruct
{
  unsigned char c;
  HexCharStruct(unsigned char _c) : c(_c) { }
};

inline std::ostream& operator<<(std::ostream& o, const HexCharStruct& hs)
{
  return (o << std::hex << (int)hs.c);
}

inline HexCharStruct hex(unsigned char _c)
{
  return HexCharStruct(_c);
}

int main()
{
  char a = 131;
  std::cout << hex(a) << std::endl;
}

Это сокращение от записи, имеет ту же эффективность, что и исходное решение, и позволяет вам выбирать "оригинальный" вывод символов. И это безопасно (не используя "злые" макросы: -))

Ответ 2

Использование:

cout << "a is " << hex << (int) a <<"; b is " << hex << (int) b << endl;

И если вы хотите заполнение с ведущими нулями, то:

#include <iomanip>
...
cout << "a is " << setw(2) << setfill('0') << hex << (int) a ; 

Поскольку мы используем C-style casts, почему бы не переместиться весь свиньи с нечувствительностью к терминалу С++ и использовать макрос!

#define HEX( x )
   setw(2) << setfill('0') << hex << (int)( x )

вы можете сказать

cout << "a is " << HEX( a );

Изменить: Сказав это, решение MartinStettner намного лучше!

Ответ 3

Подробнее об этом можно узнать на http://cpp.indi.frih.net/blog/2014/09/tippet-printing-numeric-values-for-chars-and-uint8_t/ и http://cpp.indi.frih.net/blog/2014/08/code-critique-stack-overflow-posters-cant-print-the-numeric-value-of-a-char/. Я только публикую это, потому что стало ясно, что автор этих статей не намерен.

Самый простой и правильный метод печати char как hex -

unsigned char a = 0;
unsigned char b = 0xff;
auto flags = cout.flags(); //I only include resetting the ioflags because so
                           //many answers on this page call functions where
                           //flags are changed and leave no way to  
                           //return them to the state they were in before 
                           //the function call
cout << "a is " << hex << +a <<"; b is " << +b << endl;
cout.flags(flags);

Читатели переваривают версию того, как это работает, так это то, что оператор унарного + заставляет преобразование типа op без преобразования в int с правильной подписью. Таким образом, unsigned char преобразует в unsigned int, подписанный char преобразует в int, а char преобразует в unsigned int или int в зависимости от того, подписан ли char или без знака на вашей платформе (он приходит как шоком для многих, что char является специальным и не указывается как подписанный, так и неподписанный).

Единственный минус этого метода заключается в том, что не может быть очевидно, что происходит с незнакомым с ним человеком. Тем не менее, я думаю, что лучше использовать технику, которая правильна, и научить других об этом, а не делать что-то неправильное, но более ясно.

Ответ 4

Я бы сделал это, как MartinStettner, но добавил дополнительный параметр для числа цифр:

inline HexStruct hex(long n, int w=2)
{
  return HexStruct(n, w);
}
// Rest of implementation is left as an exercise for the reader

Итак, у вас есть две цифры по умолчанию, но вы можете установить четыре, восемь или что-то еще, если хотите.

например.

int main()
{
  short a = 3142;
  std:cout << hex(a,4) << std::endl;
}

Это может показаться излишним, но, как сказал Бьярн, "библиотеки должны быть просты в использовании, а не просто писать".

Ответ 5

Я думаю, что TrungTN и anon ответ в порядке, но способ MartinStettner реализации функции hex() не очень простой и слишком темный, учитывая, что hex < (int) mychar уже является обходным решением.

вот мое решение, чтобы сделать "< < оператора проще:

#include <sstream>
#include <iomanip>

string uchar2hex(unsigned char inchar)
{
  ostringstream oss (ostringstream::out);
  oss << setw(2) << setfill('0') << hex << (int)(inchar);
  return oss.str();
}

int main()
{
  unsigned char a = 131;
  std::cout << uchar2hex(a) << std::endl;
}

Это просто не стоит реализовать оператор потока: -)

Ответ 6

Я бы предложил:

std::cout << setbase(16) << 32;

Взято из: http://www.cprogramming.com/tutorial/iomanip.html

Ответ 7

Хм, похоже, я вчера изобрел колесо... Но эй, по крайней мере, это общий ролик на этот раз:) char печатаются с двумя шестнадцатеричными цифрами, short с 4 шестнадцатеричными цифрами и т.д..

template<typename T>
struct hex_t
{
    T x;
};

template<typename T>
hex_t<T> hex(T x)
{
    hex_t<T> h = {x};
    return h;
}

template<typename T>
std::ostream& operator<<(std::ostream& os, hex_t<T> h)
{
    char buffer[2 * sizeof(T)];
    for (auto i = sizeof buffer; i--; )
    {
        buffer[i] = "0123456789ABCDEF"[h.x & 15];
        h.x >>= 4;
    }
    os.write(buffer, sizeof buffer);
    return os;
}

Ответ 8

Вы можете попробовать следующий код:

unsigned char a = 0;
unsigned char b = 0xff;
cout << hex << "a is " << int(a) << "; b is " << int(b) << endl;
cout << hex
     <<   "a is " << setfill('0') << setw(2) << int(a)
     << "; b is " << setfill('0') << setw(2) << int(b)
     << endl;
cout << hex << uppercase
     <<   "a is " << setfill('0') << setw(2) << int(a)
     << "; b is " << setfill('0') << setw(2) << int(b)
     << endl;

Вывод:

a is 0; b is ff

a is 00; b is ff

a is 00; b is ff

Ответ 9

Я бы хотел опубликовать мою новую версию re-inventing, основанную на @FredOverflow. Я сделал следующие изменения.

fix:

• Rhs operator<< должен иметь ссылочный тип const. В коде @FredOverflow h.x >>= 4 изменяет вывод h, что на удивление несовместимо со стандартной библиотекой, а тип T, по-видимому, должен быть выполнен с возможностью копирования.
• Предположим, что только CHAR_BITS является кратным 4. @FredOverflow предполагает, что char является 8-битным, что не всегда верно, в некоторых реализациях на DSP, в частности, не редкость, что char равно 16 -биты, 24-битные, 32-битные и т.д.

улучшения:

• Поддержка всех других стандартных библиотечных манипуляторов, доступных для интегральных типов, например. std::uppercase. Поскольку формат вывода используется в _print_byte, стандартные библиотечные манипуляторы все еще доступны.
• Добавьте hex_sep для печати отдельных байтов (обратите внимание, что в C/С++ "байтом" по определению является единица хранения с размером char). Добавьте параметр шаблона Sep и создайте экземпляр _Hex<T, false> и _Hex<T, true> в hex и hex_sep соответственно.
• Избегайте раздувания двоичного кода. Функция _print_byte извлекается из operator<< с параметром функции size, чтобы избежать создания экземпляра для разных size.

Подробнее о раздувании двоичного кода:

Как упоминалось в улучшении 3, независимо от того, насколько широко используются hex и hex_sep, в двоичном коде выходят только две копии (почти) дублированной функции: _print_byte<true> и _print_byte<false>. И вы могли бы понять, что это дублирование также можно устранить, используя точно такой же подход: добавьте параметр функции Sep. Да, но если это так, требуется время выполнения if(sep). Я хочу использовать общую библиотечную утилиту, которая может широко использоваться в программе, поэтому я скомпрометировал дублирование, а не накладные расходы времени исполнения. Я достиг этого с помощью времени компиляции if: С++ 11 std::conditional, накладные расходы на вызов функции можно надеяться оптимизировать на inline.

hex_print.h:

namespace Hex
{
typedef unsigned char Byte;

template <typename T, bool Sep> struct _Hex
{
    _Hex(const T& t) : val(t)
    {}
    const T& val;
};

template <typename T, bool Sep>
std::ostream& operator<<(std::ostream& os, const _Hex<T, Sep>& h);
}

template <typename T>  Hex::_Hex<T, false> hex(const T& x)
{ return Hex::_Hex<T, false>(x); }

template <typename T>  Hex::_Hex<T, true> hex_sep(const T& x)
{ return Hex::_Hex<T, true>(x); }

#include "misc.tcc"

hex_print.tcc:

namespace Hex
{

struct Put_space {
    static inline void run(std::ostream& os) { os << ' '; }
};
struct No_op {
    static inline void run(std::ostream& os) {}
};

#if (CHAR_BIT & 3) // can use C++11 static_assert, but no real advantage here
#error "hex print utility need CHAR_BIT to be a multiple of 4"
#endif
static const size_t width = CHAR_BIT >> 2;

template <bool Sep>
std::ostream& _print_byte(std::ostream& os, const void* ptr, const size_t size)
{
    using namespace std;

    auto pbyte = reinterpret_cast<const Byte*>(ptr);

    os << hex << setfill('0');
    for (int i = size; --i >= 0; )
    {
        os << setw(width) << static_cast<short>(pbyte[i]);
        conditional<Sep, Put_space, No_op>::type::run(os);
    }
    return os << setfill(' ') << dec;
}

template <typename T, bool Sep>
inline std::ostream& operator<<(std::ostream& os, const _Hex<T, Sep>& h)
{
    return _print_byte<Sep>(os, &h.val, sizeof(T));
}

}

Тест:

struct { int x; } output = {0xdeadbeef};
cout << hex_sep(output) << std::uppercase << hex(output) << endl;

выход:

de ad be ef DEADBEEF

Ответ 10

Я понимаю, что это старый вопрос, но он также является верным результатом Google в поисках решения очень похожей проблемы, которая есть у меня, что является желанием реализовать произвольное целое число с шестнадцатеричными преобразованиями строк в классе шаблона. Моя конечная цель была фактически шаблоном подкласса Gtk::Entry, который позволил бы редактировать различные целые ширины в шестнадцатеричном формате, но это рядом с точкой.

Это объединяет унарный трюк operator+ с std::make_unsigned из <type_traits>, чтобы предотвратить проблему значащих отрицательных int8_t или signed char значений, которые происходят в this ответить

В любом случае, я считаю, что это более красноречиво, чем любое другое общее решение. Он должен работать для любых подписанных или беззнаковых целочисленных типов и выдает ошибку времени компиляции, если вы пытаетесь создать экземпляр функции с любыми нецелочисленными типами.

template < 
  typename T,
  typename = typename std::enable_if<std::is_integral<T>::value, T>::type
>
std::string toHexString(const T v)
{ 
  std::ostringstream oss;
  oss << std::hex << +((typename std::make_unsigned<T>::type)v);
  return oss.str();
}

Пример использования примера:

int main(int argc, char**argv)
{
  int16_t val;
  // Prints 'ff' instead of "ffffffff". Unlike the other answer using the '+'
  // operator to extend sizeof(char) int types to int/unsigned int
  std::cout << toHexString(int8_t(-1)) << std::endl;

  // Works with any integer type
  std::cout << toHexString(int16_t(0xCAFE)) << std::endl;

  // You can use setw and setfill with strings too -OR- 
  // the toHexString could easily have parameters added to do that.
  std::cout << std::setw(8) << std::setfill('0') << 
    toHexString(int(100)) << std::endl;
  return 0;
}

Обновление: Альтернативно, если вам не нравится идея использования ostringstream, вы можете комбинировать шаблонный и унарный трюк оператора с принятым решением на основе ответа на следующие, Обратите внимание, что здесь я изменил шаблон, удалив проверку для целых типов. Использования make_unsigned может быть достаточно для обеспечения безопасности типа времени компиляции.

template <typename T>
struct HexValue 
{
  T value;
  HexValue(T _v) : value(_v) { }
};

template <typename T>
inline std::ostream& operator<<(std::ostream& o, const HexValue<T>& hs)
{
  return o << std::hex << +((typename std::make_unsigned<T>::type) hs.value);
}

template <typename T>
const HexValue<T> toHex(const T val)
{
  return HexValue<T>(val);
}

// Usage:
std::cout << toHex(int8_t(-1)) << std::endl;

Ответ 11

Я использую следующее на win32/linux (32/64 бит):

#include <iostream>
#include <iomanip>

template <typename T>
std::string HexToString(T uval)
{
    std::stringstream ss;
    ss << "0x" << std::setw(sizeof(uval) * 2) << std::setfill('0') << std::hex << +uval;
    return ss.str();
}

Ответ 12

Это также будет работать:

std::ostream& operator<< (std::ostream& o, unsigned char c)
{
    return o<<(int)c;
}

int main()
{
    unsigned char a = 06;
    unsigned char b = 0xff;
    std::cout << "a is " << std::hex << a <<"; b is " << std::hex << b << std::endl;
    return 0;
}

Ответ 13

Я использовал таким образом.

    char strInput[] = "yourchardata";
char chHex[2] = "";

int nLength = strlen(strInput);
char* chResut = new char[(nLength*2) + 1];
memset(chResut, 0, (nLength*2) + 1);



for (int i = 0; i < nLength; i++)
{
    sprintf(chHex, "%02X", strInput[i]& 0x00FF);    
    memcpy(&(chResut[i*2]), chHex, 2);
}

printf("\n%s",chResut);
delete chResut;
chResut = NULL;