Как я могу получить шестнадцатеричное значение входной строки, используя C ++?

Question

Я только начал работать с C ++, через несколько недель я понял, что C ++ не поддерживает метод или библиотеку для преобразования строки в значение Hexa. В настоящее время я работаю над методом, который будет возвращать шестнадцатеричное значение входной строки, кодированной в UTF16. Для более легкого понимания того, что я пытаюсь сделать, я покажу, что я сделал в Java.

Charset charset = Charset.forName("UTF16");
String str = "Ồ";
try {
        ByteBuffer buffer = charset.newEncoder().encode(CharBuffer.wrap(str.toCharArray()));
        byte[] bytes = new byte[buffer.limit()];
        buffer.get(bytes, 0, buffer.limit());
        System.out.println("Hex value : " + bytes); // 1ED2
    } 
catch (CharacterCodingException ex) {
        ex.printStackTrace();
    }

Что я пытаюсь сделать в C ++:

std::string convertBinToHex(std::string temp) {
    long long binaryValue = atoll(temp.c_str());
    long long dec_value = 0;
    int base = 1;
    int i = 0;
    while (binaryValue) {
        long long last_digit = binaryValue % 10;

        binaryValue = binaryValue / 10;

        dec_value += last_digit * base;

        base = base * 2;

    }
    char hexaDeciNum[10];
    while (dec_value != 0)
    {
        int temp = 0;
        temp = dec_value % 16;
        if (temp < 10)
        {
            hexaDeciNum[i] = temp + 48;
            i++;
        }
        else
        {
            hexaDeciNum[i] = temp + 55;
            i++;
        }
        dec_value = dec_value / 16;
    }
    std::string str;
    for (int j = i - 1; j >= 0; j--) {
        str = str + hexaDeciNum[j];
    }
    return str;
}

void strToBinary(wstring s, string* result)
{
    int n = s.length();
    for (int i = 0; i < n; i++)
    {
        wchar_t c = s[i];
        long val = long(c);
        std::string bin = "";
        while (val > 0)
        {
            (val % 2) ? bin.push_back('1') :
                bin.push_back('0');
            val /= 2;
        }
        reverse(bin.begin(), bin.end());
        result->append(convertBinToHex(bin));
    }
}

Моя основная функция:

 int main()
    {
        std::string result;
        std::wstring input = L"Ồ";
        strToBinary(input, &result);
        cout << result << endl;// 1ED2
        return 0;
    }

Хотя я получаю ожидаемые значения, но есть ли другой способ сделать это? Любая помощь могла бы быть полезна. Заранее спасибо.

Answer 1

Вы можете использовать от std::stringstream до write число в шестнадцатеричном формате, а затем выводить этот поток в std :: string. Вот рабочий пример:

#include <iostream>
#include <sstream>
#include <string>
#include <iomanip>

int main()
{
    int i = 0x03AD;
    std::stringstream ss;
    // The following line sets up ss to use FIXED 8-digit output with leading zeros...
    ss << std::setw(8) << std::setfill('0'); // Comment out or adjust as required
    s << std::hex << i; // The std::hex tells the stream to use HEX format
    std::string ans;
    ss >> ans;          // Put the formatted output into our 'answer' string

    std::cout << ans << std::endl; // For demo, write the string to the console
    return 0;
}

Или, чтобы преобразовать строку символов в строку шестнадцатеричных чисел:

int main()
{
    std::string ins;
    std::cout << "Enter String: ";
    std::cin >> ins;

    std::stringstream ss;
    ss << std::setfill('0') << std::hex; // Set up format
    for (auto c : ins) ss << std::setw(4) << int(c); // Need to set width for each value!

    std::string ans;
    ss >> ans;
    std::cout << ans << std::endl;
    return 0;
}

Для получения дополнительной информации о параметрах форматирования (строки) потока, см. здесь .

Не стесняйтесь просить дальнейших разъяснений и / или объяснений.

Answer 2

Просто используйте boost:

using namespace std::literals;
auto u16stringg = u"你好，世界"s;

std::string result;
boost::algorithm::hex_lower(u16stringg.begin(), u16stringg.end(), std::back_inserter(result));

Объяснение:

• u перед строкой означает создание UTF-16 строкового литерала .
• s в конце строкового литерала означает преобразование литерала в соответствующий std::basic_string, в данном случае это std::u16string, это делается с помощью using namespace std::literals; см. doc .
• повышение :: алгоритм :: hex_lower .

Вот живая демонстрация .

Answer 3

Это действительно уродливо и может быть упрощено, но это, по крайней мере, улучшение. Если бы я не был на мобильном телефоне, я бы дал что-то лучше.

auto buf = reinterpret_cast<uint8_t*>(input.data());
auto sz = (input.size() * sizeof(wchar_t));

for (size_t i = 0; i < input.size() * sizeof(wchar_t); ++i)
{
    char p[8] = {0};
    sprintf(p, "%02X", buf[i]);
    output += p;
}

Это для байтового массива, на самом деле не имеет значения, но если вы хотите использовать итерацию как wchar_t, тогда это еще проще.

for (const auto& i : input)
{
    char p[8] = {0};
    sprintf(p, "%04X", i);
    output += p;
}