3. void hexstring_from_data(const void *data, size_t len, char *output) {
    4.     const unsigned char *buf = (const unsigned char *)data;
    5.     size_t i, j;
    6.     for (i = j = 0; i < len; ++i) {
    7.         char c;
    8.         c = (buf[i] >> 4) & 0xf;
    9.         c = (c > 9) ? c + 'a' - 10 : c + '0';
    10.         output[j++] = c;
    11.         c = (buf[i] & 0xf);
    12.         c = (c > 9) ? c + 'a' - 10 : c + '0';
    13.         output[j++] = c;
    14.     }
    15. }
    17. std::string hexstring_from_data(const void *data, size_t len) {
    18.     if (len == 0) {
    19.         return std::string();
    20.     }
    21.     std::string result;
    22.     result.resize(len * 2);
    23.     hexstring_from_data(data, len, &result[0]);
    24.     return result;
    25. }
    27. //字符串转十六进制字符流 字符串
    28. std::string hexstring_from_data(const std::string &data) {
    29.     return hexstring_from_data(data.c_str(), data.size());
    30. }
    32. void data_from_hexstring(const char *hexstring, size_t length, void *output) {
    33.     unsigned char *buf = (unsigned char *)output;
    34.     unsigned char byte;
    35.     if (length % 2 != 0) {
    36.         throw std::invalid_argument("data_from_hexstring length % 2 != 0");
    37.     }
    38.     for (size_t i = 0; i < length; ++i) {
    39.         switch (hexstring[i]) {
    40.             case 'a':
    41.             case 'b':
    42.             case 'c':
    43.             case 'd':
    44.             case 'e':
    45.             case 'f':
    46.                 byte = (hexstring[i] - 'a' + 10) << 4;
    47.                 break;
    48.             case 'A':
    49.             case 'B':
    50.             case 'C':
    51.             case 'D':
    52.             case 'E':
    53.             case 'F':
    54.                 byte = (hexstring[i] - 'A' + 10) << 4;
    55.                 break;
    56.             case '0':
    57.             case '1':
    58.             case '2':
    59.             case '3':
    60.             case '4':
    61.             case '5':
    62.             case '6':
    63.             case '7':
    64.             case '8':
    65.             case '9':
    66.                 byte = (hexstring[i] - '0') << 4;
    67.                 break;
    68.             default:
    69.                 throw std::invalid_argument("data_from_hexstring invalid hexstring");
    70.         }
    71.         ++i;
    72.         switch (hexstring[i]) {
    73.             case 'a':
    74.             case 'b':
    75.             case 'c':
    76.             case 'd':
    77.             case 'e':
    78.             case 'f':
    79.                 byte |= hexstring[i] - 'a' + 10;
    80.                 break;
    81.             case 'A':
    82.             case 'B':
    83.             case 'C':
    84.             case 'D':
    85.             case 'E':
    86.             case 'F':
    87.                 byte |= hexstring[i] - 'A' + 10;
    88.                 break;
    89.             case '0':
    90.             case '1':
    91.             case '2':
    92.             case '3':
    93.             case '4':
    94.             case '5':
    95.             case '6':
    96.             case '7':
    97.             case '8':
    98.             case '9':
    99.                 byte |= hexstring[i] - '0';
    100.                 break;
    101.             default:
    102.                 throw std::invalid_argument("data_from_hexstring invalid hexstring");
    103.         }
    104.         *buf++ = byte;
    105.     }
    106. }
    108. std::string data_from_hexstring(const char *hexstring, size_t length) {
    109.     if (length % 2 != 0) {
    110.         throw std::invalid_argument("data_from_hexstring length % 2 != 0");
    111.     }
    112.     if (length == 0) {
    113.         return std::string();
    114.     }
    115.     std::string result;
    116.     result.resize(length / 2);
    117.     data_from_hexstring(hexstring, length, &result[0]);
    118.     return result;
    119. }
    122. //十六进制字符流转字符串
    123. std::string data_from_hexstring(const std::string &hexstring) {
    124.     return data_from_hexstring(hexstring.c_str(), hexstring.size());
    125. }
    127. int main()
    128. {
    129.      std::string str = "2e7c8080";
    131.      char str2[21] = {0};
    132.      str2[0] = 0x2E;
    133.      str2[1] = 0x7C;
    134.      str2[2] = 0x80;
    135.      str2[3] = 0x80;
    137.      std::string str22 = str2;
    138.      std::cout << "str: " << str << std::endl;
    139.      std::cout << "str22: " << str22 << std::endl;
    140.      std::cout << "data_from_hexstring: " << data_from_hexstring(str) << std::endl;
    141.      if (data_from_hexstring(str) == str22)
    142.          std::cout << "厉害厉害" << std::endl;                                                                                                144
    143.      std::string comp = hexstring_from_data(str22);
    144.      std::cout << " hexstring_from_data: " << comp << std::endl;
    146.      if (str == comp)
    147.          std::cout << "牛啊牛啊" << std::endl;
    149.      return 0;
    150. }