C ++将字符串转换为十六进制，反之亦然

Posted 2023-02-23

【中文标题】C ++将字符串转换为十六进制，反之亦然

【英文标题】：C++ convert string to hexadecimal and vice versa

【发布时间】：2011-03-23 20:03:59

【问题描述】：

在 C++ 中将字符串转换为十六进制和反之亦然的最佳方法是什么？

例子：

像"Hello World" 这样的字符串转换为十六进制格式：48656C6C6F20576F726C64 从十六进制 48656C6C6F20576F726C64 到字符串："Hello World"

【问题讨论】：

“到十六进制”到底是什么意思？字符串不是已经是十六进制了吗？

@FredOverflow：像“Hello World”这样的字符串转换为十六进制格式：48656C6C6F20576F726C64。

@0A0D：跨平台解决方案。

【参考方案1】：

从 C++17 开始，还有 std::from_chars。以下函数接受一串十六进制字符并返回 T 向量：

#include <charconv>

template<typename T>
std::vector<T> hexstr_to_vec(const std::string& str, unsigned char chars_per_num = 2)

  std::vector<T> out(str.size() / chars_per_num, 0);

  T value;
  for (std::size_t i = 0; i < str.size() / chars_per_num; i++) 
    std::from_chars<T>(
      str.data() + (i * chars_per_num),
      str.data() + (i * chars_per_num) + chars_per_num,
      value,
      16
    );
    out[i] = value;
  

  return out;

【讨论】：

我喜欢浏览 C/C++98 的答案，最终得到现代 C++ 的答案。 :)

【参考方案2】：

像“Hello World”这样的字符串转为十六进制格式：48656C6C6F20576F726C64。

啊，给你：

#include <string>

std::string string_to_hex(const std::string& input)

    static const char hex_digits[] = "0123456789ABCDEF";

    std::string output;
    output.reserve(input.length() * 2);
    for (unsigned char c : input)
    
        output.push_back(hex_digits[c >> 4]);
        output.push_back(hex_digits[c & 15]);
    
    return output;


#include <stdexcept>

int hex_value(unsigned char hex_digit)

    static const signed char hex_values[256] = 
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
        -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    ;
    int value = hex_values[hex_digit];
    if (value == -1) throw std::invalid_argument("invalid hex digit");
    return value;


std::string hex_to_string(const std::string& input)

    const auto len = input.length();
    if (len & 1) throw std::invalid_argument("odd length");

    std::string output;
    output.reserve(len / 2);
    for (auto it = input.begin(); it != input.end(); )
    
        int hi = hex_value(*it++);
        int lo = hex_value(*it++);
        output.push_back(hi << 4 | lo);
    
    return output;

（假设一个 char 有 8 位，所以它不是很便携，但你可以从这里获取它。）

【讨论】：

我必须屏蔽移位的 lut 索引，即 (c >> 4) & 0x0F 才能使这项工作为我工作。

@liwp：即使正确转换为 unsigned char，您也需要该掩码？

【参考方案3】：

这是另一种解决方案，很大程度上受到@fredoverflow 的启发。

/**
 * Return hexadecimal representation of the input binary sequence
 */
std::string hexitize(const std::vector<char>& input, const char* const digits = "0123456789ABCDEF")

    std::ostringstream output;

    for (unsigned char gap = 0, beg = input[gap]; gap < input.length(); beg = input[++gap])
        output << digits[beg >> 4] << digits[beg & 15];

    return output.str();

长度是预期用途中的必需参数。

【参考方案4】：

我认为有一个更简单、更优雅的解决方案。上面提到的一些方法在某些情况下甚至可能抛出未处理的异常。这是一个万无一失（因为永远不会出错）和非常快速的代码。试一试并比较速度和紧凑性方面的结果：

#include <string>

// Convert string of chars to its representative string of hex numbers
void stream2hex(const std::string str, std::string& hexstr, bool capital = false)

    hexstr.resize(str.size() * 2);
    const size_t a = capital ? 'A' - 1 : 'a' - 1;

    for (size_t i = 0, c = str[0] & 0xFF; i < hexstr.size(); c = str[i / 2] & 0xFF)
    
        hexstr[i++] = c > 0x9F ? (c / 16 - 9) | a : c / 16 | '0';
        hexstr[i++] = (c & 0xF) > 9 ? (c % 16 - 9) | a : c % 16 | '0';
    


// Convert string of hex numbers to its equivalent char-stream
void hex2stream(const std::string hexstr, std::string& str)

    str.resize((hexstr.size() + 1) / 2);

    for (size_t i = 0, j = 0; i < str.size(); i++, j++)
    
        str[i] = (hexstr[j] & '@' ? hexstr[j] + 9 : hexstr[j]) << 4, j++;
        str[i] |= (hexstr[j] & '@' ? hexstr[j] + 9 : hexstr[j]) & 0xF;
    

Test the code:

#include <iostream>
int main()

    std::string s = "Hello World!";
    std::cout << "original string: " << s << '\n';
    stream2hex(s, s);
    std::cout << "hex format: " << s << '\n';
    hex2stream(s, s);
    std::cout << "original one: " << s << '\n';

结果是：

original string: Hello World!
hex format: 48656C6C6F20576F726C6421
original one: Hello World!

【讨论】：

不适用于包含二进制的字符串，例如 0

@43.52.4D。它完美地工作。见The live example

不，我的意思是实际的二进制文件。当我在文件上尝试此算法时，某些字符没有正确转换为 HEX。

你是认真的吗？？在第二个 example 中，字符串有 8 个 NULL 字符。 @43.52.4D。

好的，我很高兴它工作正常 :) 也许我的代码有错误。

【参考方案5】：

使用查找表之类的工作，但只是矫枉过正，这里有一些非常简单的方法将字符串转换为十六进制并将十六进制返回字符串：

#include <stdexcept>
#include <sstream>
#include <iomanip>
#include <string>
#include <cstdint>

std::string string_to_hex(const std::string& in) 
    std::stringstream ss;

    ss << std::hex << std::setfill('0');
    for (size_t i = 0; in.length() > i; ++i) 
        ss << std::setw(2) << static_cast<unsigned int>(static_cast<unsigned char>(in[i]));
    

    return ss.str(); 


std::string hex_to_string(const std::string& in) 
    std::string output;

    if ((in.length() % 2) != 0) 
        throw std::runtime_error("String is not valid length ...");
    

    size_t cnt = in.length() / 2;

    for (size_t i = 0; cnt > i; ++i) 
        uint32_t s = 0;
        std::stringstream ss;
        ss << std::hex << in.substr(i * 2, 2);
        ss >> s;

        output.push_back(static_cast<unsigned char>(s));
    

    return output;

【讨论】：

VS2013 抱怨uint32_t - 不得不添加<cstdint>。

我发现 << std::setw(2) 在每次读取后都会重置 - 我必须在 for 循环中使用它。我查阅了文档，他们还指出在许多情况下宽度都会重置：en.cppreference.com/w/cpp/io/manip/setw

有趣的是，我在使用该功能时从未遇到过该问题，但查看文档您是正确的。感谢您的修复:-)

它是否正确处理'\0'？当字符串包含空字节时，我似乎得到了错误的结果。

这个函数正确处理二进制数据，但是为了提供数据，你必须使用std::string构造函数的双参数版本（见en.cppreference.com/w/cpp/string/basic_string/basic_string）：std::string(const char* s, size_type count);否则你的测试字符串将在第一个空字节处被截断：string_to_hex(std::string("\x00\x01", 2)) == "0001" // correct，而不是string_to_hex("\x00\x01") == "" // you are really feeding an empty string to the function

【参考方案6】：

这会将 Hello World 转换为 48656c6c6f20576f726c64 并打印。

#include <iostream>
#include <cstring>

using namespace std;

int main()

    char hello[20]="Hello World";

    for(unsigned int i=0; i<strlen(hello); i++)
        cout << hex << (int) hello[i];
    return 0;

【讨论】：

有人能解释一下为什么我们必须以其他复杂的方式来做吗？我觉得这个解决方案就足够了。

这要简单得多，因为它打印在函数内部。其他答案更复杂，因为它们返回一个解决方案，并且不打印任何内容。

【参考方案7】：

这会将“Hello World”转换为“48656c6c6f20576f726c64”，并将此十六进制值存储在 str1 中，还将“48656c6c6f20576f726c64”转换为“Hello World”。

#include <iostream>
#include<sstream>

using namespace std;
int hexCharToInt(char);
string hexToString(string);
int main()

    std::string str;
    std::stringstream str1;

    str="Hello World";
    for(int i=0;i<str.length();i++)
        str1 << std::hex << (int)str.at(i);
    
    std::cout << str1.str() <<"\n";
    string test = "48656c6c6f20576f726c64";
    std::cout << hexToString(test) <<"\n";
    return 0;

string hexToString(string str)
    std::stringstream HexString;
    for(int i=0;i<str.length();i++)
        char a = str.at(i++);
        char b = str.at(i);
        int x = hexCharToInt(a);
        int y = hexCharToInt(b);
        HexString << (char)((16*x)+y);
    
    return HexString.str();


int hexCharToInt(char a)
    if(a>='0' && a<='9')
        return(a-48);
    else if(a>='A' && a<='Z')
        return(a-55);
    else
        return(a-87);

【参考方案8】：

这有点快：

static const char* s_hexTable[256] = 

    "00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "0a", "0b", "0c", "0d", "0e", "0f", "10", "11",
    "12", "13", "14", "15", "16", "17", "18", "19", "1a", "1b", "1c", "1d", "1e", "1f", "20", "21", "22", "23",
    "24", "25", "26", "27", "28", "29", "2a", "2b", "2c", "2d", "2e", "2f", "30", "31", "32", "33", "34", "35",
    "36", "37", "38", "39", "3a", "3b", "3c", "3d", "3e", "3f", "40", "41", "42", "43", "44", "45", "46", "47",
    "48", "49", "4a", "4b", "4c", "4d", "4e", "4f", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59",
    "5a", "5b", "5c", "5d", "5e", "5f", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "6a", "6b",
    "6c", "6d", "6e", "6f", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "7a", "7b", "7c", "7d",
    "7e", "7f", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "8a", "8b", "8c", "8d", "8e", "8f",
    "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "9a", "9b", "9c", "9d", "9e", "9f", "a0", "a1",
    "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9", "aa", "ab", "ac", "ad", "ae", "af", "b0", "b1", "b2", "b3",
    "b4", "b5", "b6", "b7", "b8", "b9", "ba", "bb", "bc", "bd", "be", "bf", "c0", "c1", "c2", "c3", "c4", "c5",
    "c6", "c7", "c8", "c9", "ca", "cb", "cc", "cd", "ce", "cf", "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
    "d8", "d9", "da", "db", "dc", "dd", "de", "df", "e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7", "e8", "e9",
    "ea", "eb", "ec", "ed", "ee", "ef", "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "fa", "fb",
    "fc", "fd", "fe", "ff"
;

// Convert binary data sequence [beginIt, endIt) to hexadecimal string
void dataToHexString(const uint8_t*const beginIt, const uint8_t*const endIt, string& str)

    str.clear();
    str.reserve((endIt - beginIt) * 2);
    for(const uint8_t* it(beginIt); it != endIt; ++it)
    
        str += s_hexTable[*it];
    

【讨论】：

@Erik Hvatum 这是否将 std::string 转换为十六进制字符串？我不明白您所说的“二进制数据序列”是什么意思。你能发布一个调用这个函数的例子吗？

@43.52.4D dataToHexString 函数有 3 个参数。第一个是指向您希望以十六进制呈现的第一个内存字节的指针，第二个是指向您希望作为文本的最后一个内存字节的指针。第三个是经过修改以包含文本的字符串。例如：vector a; a.push_back(1); a.push_back(255);字符串 s; dataToHex(a.data(), a.data()+a.size(), s); cout

【参考方案9】：

为什么没有人使用 sprintf？

#include <string>
#include <stdio.h>

static const std::string str = "hello world!";

int main()

  //copy the data from the string to a char array
  char *strarr = new char[str.size()+1];
  strarr[str.size()+1] = 0; //set the null terminator
  memcpy(strarr, str.c_str(),str.size()); //memory copy to the char array

  printf(strarr);
  printf("\n\nHEX: ");

  //now print the data
  for(int i = 0; i < str.size()+1; i++)
  
    char x = strarr[i];
    sprintf("%x ", reinterpret_cast<const char*>(x));
  

  //DO NOT FORGET TO DELETE
  delete(strarr);

  return 0;

【讨论】：

@Abyx 但是 C++ 不是 C 的超集吗？这不是意味着我们可以使用 C 中的一些东西吗？

你真的尝试过运行它吗？它远不及正确。

【参考方案10】：

你可以试试这个。它正在工作......

#include <algorithm>
#include <sstream>
#include <iostream>
#include <iterator>
#include <iomanip>

namespace 
   const std::string test="hello world";


int main() 
   std::ostringstream result;
   result << std::setw(2) << std::setfill('0') << std::hex << std::uppercase;
   std::copy(test.begin(), test.end(), std::ostream_iterator<unsigned int>(result, " "));
   std::cout << test << ":" << result.str() << std::endl;

【讨论】：

这很不错。换一种方式你会怎么做？

这不适用于小字符值（例如，如果您的字符串是 \x01\x02\x03）

它有效，将您的字符串更改为“\\x01\\x02\\x03”。因为编译器不编译“\x”字符。

它似乎适用于小字符值，但不适用于大字符值。 test="\xf0" 应该编码为 "f0"，但它给出的是 "ffffffff0"。

我收回了这一点，它在小字符值上也确实失败了。 std::setw() 只对下一次写入有效。

【参考方案11】：

使用标准库的最简单示例。

#include <iostream>
using namespace std;

int main()

  char c = 'n';
  cout << "HEX " << hex << (int)c << endl;  // output in hexadecimal
  cout << "ASC" << c << endl; // output in ascii
  return 0;

要检查输出，codepad 返回：6e

在线ascii-to-hexadecimal conversion tool 也会产生 6e。所以它起作用了。

您也可以这样做：

template<class T> std::string toHexString(const T& value, int width) 
    std::ostringstream oss;
    oss << hex;
    if (width > 0) 
        oss << setw(width) << setfill('0');
    
    oss << value;
    return oss.str();

【讨论】：

我喜欢实际最简单的答案是如何接近底部......在转换 ascii -> hex 并且没有问题的分配中使用了第一个代码块中描述的方法。

我对此投了反对票，因为问题显然是在谈论 "strings"，而不是像 'a' 这样的单字符值。后者是微不足道的，第一个不是。

【参考方案12】：

string ToHex(const string& s, bool upper_case /* = true */)

    ostringstream ret;

    for (string::size_type i = 0; i < s.length(); ++i)
        ret << std::hex << std::setfill('0') << std::setw(2) << (upper_case ? std::uppercase : std::nouppercase) << (int)s[i];

    return ret.str();


int FromHex(const string &s)  return strtoul(s.c_str(), NULL, 16); 

【讨论】：

+1，但我会根据istringstream 实现第二个——strtoul 不是标准库函数。

为什么 FromHex 以 int 形式返回？应该作为字符串返回。

@Sebtm: 如果你调用 FromHex("10");它将返回 16，因为十六进制的 10 是 16

toHex 函数给了我奇怪的结果。事实证明，您应该将字节转换为无符号 8 位整数（Windows 中为UINT8）。

而不是特定于平台的UINT8，您可以投射(int)(unsigned char)