C++ 在十六进制格式和二进制格式之间转换字符串

是否有任何实用程序或库提供了一个简单的函数来在十六进制/二进制格式之间转换字符串？我一直在搜索SO，目前正在使用查找表方法。顺便说一下，因为它可能是一个长字符串，所以我不会考虑将字符串转换为整数并处理格式转换，因为长字符串可能大于Max（或其他整数数据类型）。 例如：

0xA1 => 10100001
11110001 => 0xF1

---

PS：我的项目使用的是Boost1.44，有点过时了。因此，如果该实用程序来自Boost，希望它在1.44中可用。

您可以使用

std:：stringstream

、

std:：hex

和

std:：bitset

的组合在C++03中在十六进制和二进制之间进行转换

下面是一个例子：

#include <iostream>
#include <sstream>
#include <bitset>
#include <string>

using namespace std;

int main()
{
    string s = "0xA";
    stringstream ss;
    ss << hex << s;
    unsigned n;
    ss >> n;
    bitset<32> b(n);
    // outputs "00000000000000000000000000001010"
    cout << b.to_string() << endl;
}

#包括
#包括
#包括
#包括
使用名称空间std；
int main（）
{
字符串s=“0xA”；
细流ss；
ss n；
位集b（n）；
//输出“000000000000000000000001010”
cout下面的代码包括两个函数，它们将完全按照您的要求执行。这是基于Silex的答案，但有一些额外的字符串操作，以匹配您在问题中给出的示例输出

#include <iostream>
#include <sstream>
#include <bitset>
#include <string>
#include <boost/algorithm/string.hpp>

using namespace std;

const unsigned g_unMaxBits = 32;

string Hex2Bin(const string& s)
{
    stringstream ss;
    ss << hex << s;
    unsigned n;
    ss >> n;
    bitset<g_unMaxBits> b(n);

    unsigned x = 0;
    if (boost::starts_with(s, "0x") || boost::starts_with(s, "0X")) x = 2;
    return b.to_string().substr(32 - 4*(s.length()-x));
}

string Bin2Hex(const string& s)
{
    bitset<g_unMaxBits> bs(s);
    unsigned n = bs.to_ulong();
    stringstream ss;
    ss << hex << n;
    return "0x" + boost::to_upper_copy(ss.str());
}

int main()
{
    cout << "0xA1 => " << Hex2Bin("0xA1") << endl;
    cout << "B3 => " << Hex2Bin("B3") << endl;
    cout << "11110001 => " << Bin2Hex("11110001") << endl;

    return 0;
}

#包括
#包括
#包括
#包括
#包括
使用名称空间std；
常量无符号g_unMaxBits=32；
字符串Hex2Bin（常量字符串和s）
{
细流ss；
ss n；
位集b（n）；
无符号x=0；
如果（boost:：以（s，“0x”）开头| | boost:：以（s，“0x”）开头)x=2；
返回b.to_string（）.substr（32-4*（s.length（）-x））；
}
字符串Bin2Hex（常量字符串和s）
{
位集b（s）；
无符号n=bs.to_ulong（）；
细流ss；
ss最简单的解决方案，不使用位集或任何库，仅使用移位运算符和std:：hex转换整个十六进制字符串

将十六进制字符串转换为二进制数字的示例代码：

string s = "FF 0F F0 C3 10";
stringstream ss;
ss << hex << s;

unsigned int n;
while(ss >> n){
   for (int i = 8 -1; i >= 0; i--) 
    cout << ((n >> i) & 1) ? "1" : "0";
 cout << std::endl;
}

如果您想要一个简明的c++11解决方案，请点击这里：

string hextobin(const string &s){
    string out;
    for(auto i: s){
        uint8_t n;
        if(i <= '9' and i >= '0')
            n = i - '0';
        else
            n = 10 + i - 'A';
        for(int8_t j = 3; j >= 0; --j)
            out.push_back((n & (1<<j))? '1':'0');
    }

    return out;
}

string bintohex(const string &s){
    string out;
    for(uint i = 0; i < s.size(); i += 4){
        int8_t n = 0;
        for(uint j = i; j < i + 4; ++j){
            n <<= 1;
            if(s[j] == '1')
                n |= 1;
        }

        if(n<=9)
            out.push_back('0' + n);
        else
            out.push_back('A' + n - 10);
    }

    return out;
}

string-hextobin（常量字符串&s）{
串出；
用于（自动i:s）{
uint8_t n；
如果（i='0'）
n=i-‘0’；
其他的
n=10+i-‘A’；
对于（int8_t j=3；j>=0；--j）
向外。向后推（（n&（1
）#包括
#包括
#包括
#包括
#包括
使用名称空间std；
字符hx[]={'0'，'1'，'2'，'3'，'4'，'5'，'6'，'7'，'8'，'9'，'A'，'B'，'C'，'D'，'E'，'F'}；
内联int-hextoint（字符输入）{
int const x=in；
return（x什么类型的“十六进制/二进制格式”？请给出一些示例？您可能需要将声明unsigned n更改为unsigned long n；（是的，其中的两个long）位集需要在编译时定义的大小。这如何处理变长十六进制字符串？@KokHowTeh：您可以使用或其他解决方案。
11111111
00001111
11110000
11000011
00001010

string hextobin(const string &s){
    string out;
    for(auto i: s){
        uint8_t n;
        if(i <= '9' and i >= '0')
            n = i - '0';
        else
            n = 10 + i - 'A';
        for(int8_t j = 3; j >= 0; --j)
            out.push_back((n & (1<<j))? '1':'0');
    }

    return out;
}

string bintohex(const string &s){
    string out;
    for(uint i = 0; i < s.size(); i += 4){
        int8_t n = 0;
        for(uint j = i; j < i + 4; ++j){
            n <<= 1;
            if(s[j] == '1')
                n |= 1;
        }

        if(n<=9)
            out.push_back('0' + n);
        else
            out.push_back('A' + n - 10);
    }

    return out;
}

string s = "FF11";
string b = hextobin(s);
cout << b << endl; // prints 1111111100010001
string h = bintohex(b);
cout << h << endl; // prints FF11

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

using namespace std;

char hx[] = { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F' };

inline int hextoint(char in) {
    int const x = in;
    return (x <= 57) ? x - 48 : (x <= 70) ? (x - 65) + 0x0a : (x - 97) + 0x0a;
}

string binaryToHEX(const string& input) {
    size_t len = input.length();
    if (len % 4 != 0) {
        return "";
    }
    string output = string(len / 4, '0');
    size_t outputoffset = 0;
    for (size_t i = 0; i < len; i += 4) {
        int val = 0;
        for (size_t j = 0; j < 4; j++) {
            if (input[i + j] == '1') {
                val += (1 << (3 - j));
            }
        }
        output[outputoffset++] = hx[val];
    }
    return output;
}

string HEXToBinary(const string& input) {
    size_t len = input.length();
    string output = string(len * 4, '0');
    for (size_t i = 0; i < len; i++) {
        unsigned int offset = i * 4;
        int val = hextoint(input[i]);
        for (size_t j = 0; j < 4; j++) {
            output[offset + 3 - j] = ((val & (1 << j)) != 0) ? '1' : '0';
        }
    }
    return output;
}

int main() {
    cout << binaryToHEX("1010101101000010") << endl;
    cout << HEXToBinary("AB42") << endl;
    system("pause");
    return 1;
}