如何在 c++ 中将无符号字符打印为十六进制 使用ostream？

Question

我想在 C++ 中使用无符号 8 位变量。 就算术而言， unsigned char 或 uint8_t 都可以解决问题（这是预期的，因为 AFAIK uint8_t 只是 uint8_t 的别名code>unsigned char，或者调试器呈现它

问题是，如果我在 C++ 中使用 ostream 打印变量，它会将其视为 char 如果我有：

unsigned char a = 0;
unsigned char b = 0xff;
cout << "a is " << hex << a <<"; b is " << hex << b << endl;

那么输出是：

a is ^@; b is 377

而不是

a is 0; b is ff

我尝试使用。 uint8_t，但正如我之前提到的，它被 typedef 为 unsigned char，所以它的作用是相同的

编辑：< /strong> 我在代码中的很多地方都这样做了，有什么方法可以每次我想打印时都转换为 int 吗？

Answer 1

使用：

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 风格的强制转换，为什么不彻底解决 C++ 终端的缺陷并使用宏呢！

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

然后你可以说

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

编辑：话虽如此，MartinStettner 的解决方案要好得多！

Answer 2

我建议使用以下技术：

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

它编写起来很短，与原始解决方案具有相同的效率，并且它允许您选择使用“原始”字符输出。 而且它是类型安全的（不使用“邪恶”宏:-)）

Answer 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 打印为十六进制的最简单、最正确的技术是

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

读者摘要版本，其工作原理是一元 + 运算符强制将 no op 类型转换为具有正确符号的 int。 因此，unsigned char 转换为 unsigned int，signed char 转换为 int，char 转换为 unsigned int 或 int，具体取决于 char 在您的平台上是有符号的还是无符号的（令许多人感到震惊的是 char 是特殊的）并且未指定为有符号或无符号）。

这种技术的唯一缺点是，对于不熟悉该技术的人来说，发生的事情可能并不明显。 然而，我认为最好使用正确的技术并教给其他人，而不是做一些不正确但更直接清晰的事情。

Answer 4

嗯，这对我有用：

std::cout << std::hex << (0xFF & a) << std::endl;

如果你按照建议转换 (int) ，如果它的最高有效位是 1，它可能会在 a 的左边添加 1。所以这样做二进制 AND 运算保证输出的左侧位将被 0 填充，并将其转换为 unsigned int ，强制 cout 将其打印为十六进制。

我希望这有帮助。

Answer 5

在 C++20 中，您可以使用 std::format< /a> 执行此操作：

std::cout << std::format("a is {:x}; b is {:x}\n", a, b);

输出：

a is 0; b is ff

如果不可用，您可以使用 {fmt} 库 , std::format 是基于的。 {fmt} 还提供了 print 功能，使这变得更加简单和高效 (godbolt< /a>):

fmt::print("a is {:x}; b is {:x}\n", a, b);

免责声明：我是 {fmt} 和 C++20 std::format 的作者。

Answer 6

嗯，看来我昨天重新发明了轮子...但是，嘿，至少这次是一个通用轮子:) char 打印有两个十六进制数字，shorts 具有 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;
}

Answer 7

我认为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;
}

不值得实现流操作符:-)

Answer 8

我认为我们缺少对这些类型转换如何工作的解释。

char 是依赖于平台的有符号 或无符号。 在 x86 中，char 相当于 signed char。

当整型（char、short、int、long）转换为更大容量类型时，对于无符号类型，通过在左侧添加零来进行转换；对于有符号类型，则通过符号扩展来进行转换。 符号扩展包括将原始数字的最高有效（最左边）位复制到左侧，直到达到目标类型的位大小。

因此，如果我默认系统处于 signed char 中，并且我这样做：

char a = 0xF0; // Equivalent to the binary: 11110000
std::cout << std::hex << static_cast<int>(a);

我们将获得 F...F0，因为前导 1 位已被延长。

如果我们想确保在任何系统中只打印 F0 ，我们就必须进行额外的中间类型转换为 unsigned char 以便添加零，并且，因为它们对于只有 8 位的整数来说并不重要，因此不会打印：

char a = 0xF0; // Equivalent to the binary: 11110000
std::cout << std::hex << static_cast<int>(static_cast<unsigned char>(a));

这会产生 F0

Answer 9

我会像 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;
}

这可能看起来有点矫枉过正，但正如 Bjarne 所说：“库应该易于使用，而不是易于编写”。

Answer 10

我建议：

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

摘自：
http://www.cprogramming.com/tutorial/iomanip.html

Answer 11

您可以尝试以下代码：

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 为 ff

a 为 00； b 为 ff

a 为 00； b 是 FF

Answer 12

我在 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();
}

Answer 13

我意识到这是一个老问题，但它也是搜索我遇到的非常相似问题的解决方案的顶级谷歌结果，即希望在模板类中实现任意整数到十六进制字符串的转换。 我的最终目标实际上是一个 Gtk::Entry 子类模板，它允许以十六进制编辑各种整数宽度，但这不是重点。

这将一元 operator+ 技巧与 中的 std::make_unsigned 结合起来，以防止符号扩展负数 int8_t 的问题 或 signed char 值出现在 这个答案

无论如何，我相信这是比任何其他通用解决方案更简洁。 它应该适用于任何有符号或无符号整数类型，并且如果您尝试使用任何非整数类型实例化该函数，则会抛出编译时错误。

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;

Answer 14

我想发布我基于@FredOverflow 的重新发明版本。 我做了以下修改。

修复：

• operator<< 的 Rhs 应为 const 引用类型。 在 @FredOverflow 的代码中，hx >>= 4 更改了输出 h，令人惊讶的是，它与标准库不兼容，并且类型 T 是要求是可复制构造的。
• 假设只有 CHAR_BITS 是 4 的倍数。@FredOverflow 的代码假设 char 是 8 位，这并不总是正确的，特别是在 DSP 上的某些实现中，它不是不常见的是 char 为 16 位、24 位、32 位等。

改进：

• 支持所有其他可用于整数类型的标准库操纵器，例如 std::uppercase 。 由于_print_byte中使用了格式输出，因此标准库操纵器仍然可用。
• 添加 hex_sep 以打印单独的字节（请注意，在 C/C++ 中，“字节”根据定义是大小为 char 的存储单元）。 添加模板参数 Sep 并以 hex 实例化 _Hex 和 _Hex和 hex_sep 分别。
• 避免二进制代码膨胀。 函数_print_byte是从operator<<中提取出来的，带有函数参数size，以避免实例化不同的大小。

关于二进制代码膨胀的更多信息：

正如改进 3 中提到的，无论 hex 和 hex_sep 使用得多么广泛，二进制代码中只会存在（几乎）重复的函数的两个副本：_print_byte 和_print_byte。 您可能会意识到，也可以使用完全相同的方法消除这种重复：添加函数参数 sep。 是的，但如果这样做，则需要运行时 if(sep)。 我想要一个可以在程序中广泛使用的通用库实用程序，因此我在重复而不是运行时开销上做出了妥协。 我通过使用编译时 if 实现了这一点：C++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

Answer 15

如果您使用预填充和签名字符，请注意不要附加不需要的“F”

char out_character = 0xBE;
计算<< setfill（'0'）<< setw（2）<< 十六进制 << unsigned Short(out_character);

打印： ffbe

使用 int 而不是 ffffffbe 中的 Short 结果

为了防止不需要的 f，您可以轻松地将它们屏蔽掉。

char out_character = 0xBE;
计算<< setfill（'0'）<< setw（2）<< 十六进制 << 无符号短(out_character) & 0xFF;

Answer 16

这也将起作用：

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

Answer 17

我曾经用过这种方式。

    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;