C++ convert string to hexadecimal and vice versa

Question

What is the best way to convert a string to hex and vice versa in C++?

Example:

A string like "Hello World" to hex format: 48656C6C6F20576F726C64
And from hex 48656C6C6F20576F726C64 to string: "Hello World"

What exactly do you mean by "to hex"? Isn't the string already in hex? — fredoverflow, Aug 01 '10 at 11:27
@FredOverflow: A string like "Hello World" to hex format: 48656C6C6F20576F726C64. — Sebtm, Aug 01 '10 at 16:41

fredoverflow · Accepted Answer · 2020-07-11T09:21:28.577

A string like "Hello World" to hex format: 48656C6C6F20576F726C64.

Ah, here you go:

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

(This assumes that a char has 8 bits, so it's not very portable, but you can take it from here.)

I had to mask the shifted lut index, i.e. (c >> 4) & 0x0F to make this work for me. — liwp, Aug 24 '11 at 15:47
@liwp: you need that mask even after correctly casting to *unsigned* char? — yau, Jan 20 '17 at 21:39

score 34 · Answer 2 · edited Aug 01 '10 at 14:39

34

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

edited Aug 01 '10 at 14:39

strager

88,763
26
134
176

answered Aug 01 '10 at 10:19

Krevan

1,611
1
14
12

3

+1, but I would implement the second in terms of `istringstream` -- strtoul is not a standard library function. – Billy ONeal Aug 01 '10 at 14:40
1

Why FromHex returns as an int? Should return as a string. – Sebtm Aug 01 '10 at 16:46
@Sebtm: if you call FromHex("10"); it will return 16, since 10 in hex is 16 – Krevan Aug 01 '10 at 17:12
1

`toHex` function gave me strange results. It turns out you should convert the byte into an unsigned 8-bit integer (`UINT8` in windows). – atoMerz Feb 15 '14 at 06:38
1

instead of platform specific `UINT8` you can cast `(int)(unsigned char)` – slawekwin Aug 08 '16 at 06:54

X-Istence · Answer 3 · 2015-11-03T22:26:03.800

20

Using lookup tables and the like works, but is just overkill, here are some very simple ways of taking a string to hex and hex back to a string:

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

edited Nov 03 '15 at 22:26

answered Apr 20 '13 at 22:22

X-Istence

16,324
6
57
74

VS2013 complained about `uint32_t` - had to add ``. – thomthom Oct 20 '15 at 20:27
1

I found that `<< std::setw(2)` got reset after each read - and I had to use it inside the `for` loop. I looked up the docs and they also states that the width is reset in many scenarios: http://en.cppreference.com/w/cpp/io/manip/setw – thomthom Nov 03 '15 at 22:19
Interesting, I never ran into that issue while using the function, but looking at the docs you are correct. Thanks for the fix :-) – X-Istence Nov 03 '15 at 22:25
1

Does it handle '\0' correctly? I seem to get too wrong results when the string contains null bytes. – allo May 28 '19 at 08:44
This function **correctly handles binary data**, but in order to feed that data, **you'll have to use the two-parameters version of `std::string` constructor** (see https://en.cppreference.com/w/cpp/string/basic_string/basic_string): `std::string(const char* s, size_type count);` Otherwise your test string will be truncated at the first null byte: `string_to_hex(std::string("\x00\x01", 2)) == "0001" // correct`, versus `string_to_hex("\x00\x01") == "" // you are really feeding an empty string to the function` – muxator Aug 25 '21 at 10:51

polfosol ఠ_ఠ · Answer 4 · 2016-08-21T09:36:03.470

16

I think there is a much simpler and more elegant solution. Some of the above-mentioned methods may even throw unhandled exceptions in some cases. Here is a fool-proof (as in never goes wrong) and very fast code. Just try it and compare the results in terms of speed and compactness:

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

and the result is:

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

edited Aug 21 '16 at 09:36

answered Feb 24 '16 at 10:46

polfosol ఠ_ఠ

1,840
26
41

Does not work with string that contain binary such as 0 – 43.52.4D. Apr 16 '16 at 22:29
@43.52.4D. It works perfectly. See [The live example](http://melpon.org/wandbox/permlink/vhg21SHTviOEb4X7) – polfosol ఠ_ఠ Apr 17 '16 at 10:27
No, I meant actual binary. When I tried this algorithm on a file, some characters did not get converted to HEX properly. – 43.52.4D. Apr 17 '16 at 22:35
Did you read the file in binary mode? Can you show me your code or paste it somewhere? @43.52.4D. – polfosol ఠ_ఠ Apr 18 '16 at 04:15
[Another example with actual binary](http://melpon.org/wandbox/permlink/gCnda6hQIhKIIByo) – polfosol ఠ_ఠ Apr 19 '16 at 06:03
Hmmm idk, personally when I tried it, it didn't seem to convert all bytes properly. Does it work when the data contains NULL characters? – 43.52.4D. Apr 19 '16 at 17:09
2

Are you serious?? In the second [example](http://melpon.org/wandbox/permlink/gCnda6hQIhKIIByo) the string had 8 NULL characters. @43.52.4D. – polfosol ఠ_ఠ Apr 20 '16 at 07:44
1

Okay, I'm glad it works fine :) Maybe I had a bug in my code. – 43.52.4D. Apr 20 '16 at 23:37
You actually want to use pass-by-reference on both `str` param on of the first method and `hexstr` on the second method. For example use: `const std::string& str`, since now you are creating a copy of the source. – Melroy van den Berg Apr 18 '23 at 19:29

score 16 · Answer 5 · edited May 19 '21 at 09:45

16

As of C++17 there's also std::from_chars. The following function takes a string of hex characters and returns a vector of 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;
}

edited May 19 '21 at 09:45

Gelldur

11,187
7
57
68

answered Oct 06 '18 at 22:12

Nico

2,645
19
25

9

I like to browse through C / C++98 answers to finally get to modern C++ answer. :) – Leśny Rumcajs Nov 21 '18 at 19:45

score 14 · Answer 6 · answered Jun 25 '12 at 13:42

14

You can try this. It's Working...

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

answered Jun 25 '12 at 13:42

Mahmut EFE

5,137
5
46
56

This is pretty nice. How would you do it the other way? – Timmmm Sep 20 '12 at 22:53
This does not work with small character values (e.g. If your string is \x01\x02\x03) – BatchyX Dec 14 '12 at 09:50
it works, change your string like "\\x01\\x02\\x03". because compiler doesnt compile "\x" character. – Mahmut EFE Dec 14 '12 at 13:24
2

It seems to work for small character values, but not large ones. test="\xf0" should encode to "f0", but it gives "fffffff0". – richvdh Aug 16 '13 at 16:16
2

I take that back, it does fail on small character values too. std::setw() only has an effect for the next write. – richvdh Aug 16 '13 at 16:23
1

@richvdh - did you find out why `fffffff0` would be returned? EDIT: Found the solution below: https://stackoverflow.com/a/16125797/486990 the double static cast was needed. – thomthom Dec 10 '18 at 17:05

score 8 · Answer 7 · 2010-08-01T14:48:08.063

8

Simplest example using the Standard Library.

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

To check the output, codepad returns: 6e

and an online ascii-to-hexadecimal conversion tool yields 6e as well. So it works.

You can also do this:

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

edited Aug 01 '10 at 14:48

answered Aug 01 '10 at 13:16

I love how the actual simplest answer is toward the bottom... used the method described in first block of code in an assignment that converts ascii -> hex and had no issues. – Joe Sep 01 '17 at 21:21
4

I downvoted this as the questions was clearly talking about `"strings"`, not single-character values such as `'a'`. The latter is trivial, first one is not. – Multisync Feb 20 '18 at 12:42

score 6 · Answer 8 · answered Feb 09 '13 at 13:26

This is a bit faster:

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 Does this convert an std::string to hex string? I don't understand what you mean by "Binary data sequence". Could you post an example of calling this function? — 43.52.4D., Apr 16 '16 at 23:10
@43.52.4D The dataToHexString function takes 3 arguments. The first is a pointer to the first byte of memory you wish to have rendered in hex, the second is a pointer to the byte of memory after the last you wish to have as text. The third is a string which is modified to contain the text. For example: vector a; a.push_back(1); a.push_back(255); string s; dataToHex(a.data(), a.data()+a.size(), s); cout << s << '\n'; // "00ff" — Erik Hvatum, Apr 18 '16 at 02:36
Someone used a similar technique in C back in 1990, when compilers were small and space was limited to 64K - the compiler ran out of string space!!! Initialized the array from a loop and it magically managed to compiled. — cup, Oct 26 '22 at 16:18

score 3 · Answer 9 · answered Jul 23 '15 at 04:48

3

This will convert Hello World to 48656c6c6f20576f726c64 and print it.

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

answered Jul 23 '15 at 04:48

Dilushan

143
1
10

Can someone explain why do we have to do in the other complicated ways? I felt this solution is enough. – Sean Aug 23 '19 at 23:21
This is a lot simpler because it's printed inside of the function. The other answers are more complicated because they return a solution, and don't print anything. – theicfire Oct 14 '19 at 21:55
1

@sea You'll find that part of the added complexity is due to correctness requirements. This solution glosses over this requirement. You'll find out once your input is, say, `"Hello\nWorld"`. This produces a string of hexadecimal digits that can no longer be unambiguously converted back. Indeed, for every problem there is a solution that's simple, intuitive, and wrong. – IInspectable Mar 22 '22 at 06:56

psychoslave · Answer 10 · 2020-01-09T17:06:37.423

Here is an other solution, largely inspired by the one by @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();
}

Length was required parameter in the intended usage.

Anshul Jain · Answer 11 · 2014-09-18T22:42:34.777

This will convert "Hello World" to "48656c6c6f20576f726c64" and will store this hex value in str1 and also will convert "48656c6c6f20576f726c64" to "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);
}

score 1 · Answer 12 · answered Mar 06 '22 at 12:52

1

#include "boost/algorithm/hex.hpp"
std::string hexed = boost::algorithm::hex(std::string("input"));

https://www.boost.org/doc/libs/1_78_0/boost/algorithm/hex.hpp

answered Mar 06 '22 at 12:52

user1050755

11,218
4
45
56

BRT · Answer 13 · 2022-12-15T09:46:23.367

This works for printing UTF-8 encoded strings (which are variable in length)

// std::string
void printHex1(const std::string & str)
{
  printf("%s 1: ", str.c_str());
  for (size_t i = 0; i < str.size(); i++)
    printf("%X ", str[i]);
  printf("\n");
}

// c-style string
void printHex2(const char * buf)
{
  printf("%s 2: ", buf);
  size_t i = 0;
  while (buf[i] != 0) {
    printf("%X ", buf[i]);
    i++;
  }
  printf("\n");
}

Little test

std::string test_vector = "Cigueña";
char c_vector[128];
strncpy(c_vector, test_vector.c_str(), 128);
printHex1(test_vector);
printHex2(c_vector);

The output:

Cigueña 1: 43 69 67 75 65 FFFFFFC3 FFFFFFB1 61 
Cigueña 2: 43 69 67 75 65 FFFFFFC3 FFFFFFB1 61

See how UTF-8 characters ñ are encoded using more bytes.

score -1 · Answer 14 · edited Aug 12 '12 at 07:41

-1

Why has nobody used 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;
}

edited Aug 12 '12 at 07:41

Bart

19,692
7
68
77

answered Aug 12 '12 at 01:26

Alexander Frankland

31
1

@Abyx But isn't C++ a superset of C? Doesn't this mean that we can use some stuff from C? – Colorless Photon Jul 04 '13 at 04:14
3

Did you actually try running this? it's *nowhere near* correct. – richvdh Aug 16 '13 at 16:32

C++ convert string to hexadecimal and vice versa

14 Answers14

Linked

Related