How can I get the hex value of an input string using C++?

Question

I just started working with C++, after a few weeks I figured out that C++ doesn't support a method or library to convert a string to Hexa value. Currently, I'm working on a method that will return the hexadecimal value of an input string encode in UTF16. For an easier understanding of what I'm trying to do, I will show what I have done in 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();
    }

What I have try to do in 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));
    }
}

My main function:

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

Although I get the expected values, but is there any other way to do it? Any help would be really appreciated. Thanks in advance.

Pickle Rick · Accepted Answer · 2019-11-08T09:51:47.730

3

This is really ugly and can be simplified but it's at least an improvement. If I wasn't on mobile I would give something better.

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

That's for a byte array, doesn't really matter but if you want to iterate as wchar_t then it's even easier.

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

edited Nov 08 '19 at 09:51

answered Nov 08 '19 at 09:47

Pickle Rick

808
3
6

You can give an editable version later, I will try what you just showed be first. Thanks a lot. – Nguyễn Đức Tâm Nov 08 '19 at 09:48
It gives me an error with `reinterpret_cast`, any help please? – Nguyễn Đức Tâm Nov 08 '19 at 09:53
Full error : `'reinterpret_cast': cannot convert from 'const _Elem *' to 'uint8_t *'` – Nguyễn Đức Tâm Nov 08 '19 at 09:54
Show the whole line. – Pickle Rick Nov 08 '19 at 09:56
Not the error, the line of code it references. Assuming ``input`` is an ``std::wstring`` then it should have a ``data()`` method which returns a pointer to the buffer. Given your error, I'm guessing you're not casting what you should be. – Pickle Rick Nov 08 '19 at 09:59
`auto buf = reinterpret_cast(input.data());` My input is a wstring. – Nguyễn Đức Tâm Nov 08 '19 at 10:02
Works fine for me, [this](https://onlinegdb.com/ByWgf6fjB) was a nightmare to type out with how crap that site is for mobile. lol – Pickle Rick Nov 08 '19 at 10:24
Now it's fine, you don't use `reinterpret_cast` in your link. Thanks for your help, really appreciated. – Nguyễn Đức Tâm Nov 08 '19 at 10:27
Can I ask you one more question? – Nguyễn Đức Tâm Nov 08 '19 at 10:28
The cast worked fine for me too, just gave the other option in the link -- although you need to cast as const. You can ask but I can't promise I'll answer, half asleep atm. :) – Pickle Rick Nov 08 '19 at 10:37
What if the input is not a `wstring` but a `string` I don't think it will work. – Nguyễn Đức Tâm Nov 08 '19 at 10:40

Adrian Mole · Answer 2 · 2019-11-08T11:31:35.770

3

You can use std::stringstream to write a number in hex format, then output that stream to a std::string. Here's a working example:

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

Or, to convert a character string into a string of hex numbers:

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

For more information on (string)stream formatting options, see here.

Feel free to ask for further clarification and/or explanation.

edited Nov 08 '19 at 11:31

answered Nov 08 '19 at 09:54

Adrian Mole

49,934
160
51
83

The input is actually a `std::string`, how about that? – Nguyễn Đức Tâm Nov 08 '19 at 09:56
No problem! Where I've written `ss >> ans;` you can replace with `ss >> temp;`. I'll edit soon to show how you can include leading zeros (if you want to). – Adrian Mole Nov 08 '19 at 09:58
1

I want to convert a string to Hexa values, not a number to Hexa value. In my post, the input string is `std::wstring = L"Ồ";` . – Nguyễn Đức Tâm Nov 08 '19 at 10:00
1

Then just take each character of your `string` in turn (either as `char` or `wchar_t`, depending on the format) and use each value in place of the 'int' in my example. – Adrian Mole Nov 08 '19 at 10:04
Thanks, appreciate your help. – Nguyễn Đức Tâm Nov 08 '19 at 10:05
1

@NguyễnĐứcTâm Note that, depending on the endianness of `wchar_t`, the output might be different from the output you get in Java. This may or may not be important. – sebrockm Nov 08 '19 at 10:33
@sebrockm thanks for your note, I will remember that. – Nguyễn Đức Tâm Nov 08 '19 at 10:35

score 3 · Answer 3 · answered Nov 08 '19 at 10:06

3

Just use boost:

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

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

Explanation:

u on front of the string means create UTF-16 string literal.
s on the end of string literal means convert literal to respective std::basic_string, in this case it is std::u16string, this is done by using namespace std::literals; see doc.
boost::algorithm::hex_lower.

Here is live demo.

answered Nov 08 '19 at 10:06

Marek R

32,568
6
55
140

Thanks for your answer, but unfortunately I'm just allowed to use C++ standard library :(. – Nguyễn Đức Tâm Nov 08 '19 at 10:09
But using Boost is a good option which I will try to convince my boss to accept it. – Nguyễn Đức Tâm Nov 08 '19 at 10:10
Note that `boot` is usually first step to be placed in standard library. There are exceptions like `fmt` (not part of boost) which will be added to C++20. – Marek R Nov 08 '19 at 10:12
Standard Library should be here: https://en.cppreference.com/w/, which is not include `boost`. – Nguyễn Đức Tâm Nov 08 '19 at 10:14
You've missed my point. Lots of stuff are prototyped in boost before it is introduced to standard library. Examples: `shared_ptr` (C++11), `filesystem` (C++17). All this was available in `boost` before it appeared in standard. – Marek R Nov 08 '19 at 12:03
I know but currently, C++14 Standard Library is my only choice and I'm not allowed to use any of boost library(it's open-source). – Nguyễn Đức Tâm Nov 09 '19 at 05:42

How can I get the hex value of an input string using C++?

3 Answers3