How to concatenate an hex to a string in C

Question

I'm trying to create a string that's composed with multiple parts. It starts as a normal string and at some point a function is called that fills a pointer with an hex number. Like shown below.

PVOID hexval = NULL;
PCTSTR mystring = TEXT("BLA");

function(&hexval);

mystring += hexval;  // just an idea of what I want, not actual code

As shown above I want mystring to have the hexvalue appended to it. Assume my hexvalue is 0x424C41. I want to end with mystring being "BLABLA".

What's the best way to do this?

`mystring +=` is a bad sign if you are actually writing C code. — David Hoelzer, May 11 '19 at 16:35
The most standard option is to use `sprintf`. https://en.cppreference.com/w/c/io/fprintf — bipll, May 11 '19 at 16:37
@einpoklum It prepends a string literal with `L` when `UNICODE` is defined to make it a wide string (UTF-16) — Swordfish, May 11 '19 at 16:38
@einpoklum The TEXT macro identifies a string as Unicode when UNICODE is defined by a preprocessor directive during compilation. Otherwise, the macro identifies a string as an ANSI string. @ David as I say in the comments that line is only to make clear what I would like to do. — Diego, May 11 '19 at 16:40
@einpoklum `TEXT` macro is [explained here](https://learn.microsoft.com/en-us/windows/desktop/api/winnt/nf-winnt-text). — Weather Vane, May 11 '19 at 17:05

score 1 · Answer 1 · answered May 11 '19 at 16:40

(Assuming I understand you correctly, and that UNICODE is not define by the preprocessor)

you should do the following:

Allocate space for a string which would contain both the original text and the new "text".
Copy the original string to the new location.
Concatenate the bytes of the hexval, from lowest to highest, after the copy of the original string.

There are two tricky points here:

You haven't explained how the "hex data" is terminated. Is there always a zero-valued byte at the "end" of it? Or - does it have a fixed size?
The order of bytes of the hex value may not be the order of bytes you want in a string. Some machines store the lowest byte first ("little-endian"; in your example, it would be 0x41, 0x4C, 0x42, 0x00 - assuming it's a 4-byte value) while others store the highest byte first ("big endian"). If you don't know you're on a little-endian machine, you'll need to reorder the bytes and you can't just copy from hexval directly.

HOWEVER! I advise you against doing any of this. It is much better to avoid getting into a situation in which you need to perform these brute-force conversions. I would bet you could probably solve whatever problem you're facing differently.

And is sprintf the best way to do it? The hex data has always the same fixed size. — Diego, May 11 '19 at 16:54
@Diego: No, I didn't say `sprintf()` was the best way to do "it", because I don't know what "it" is. The three steps I suggested, on a little-endian machine would involve `malloc()` for allocation and `strcpy()` / `strncpy()` for copying the the two strings. — einpoklum, May 11 '19 at 17:05

Swordfish · Accepted Answer · 2019-05-11T17:45:56.550

#include <stddef.h>
#include <stdlib.h>

#include <windows.h>
#include <tchar.h>

int main(void)
{
    ULONG_PTR value  = 0x424C41;
    LPVOID hexval    = &value;
    PCTSTR mystring  = _T("BLA");

    size_t length    = _tcslen(mystring);
    size_t new_size  = length + sizeof(ULONG_PTR) + 1;

    LPTSTR new_string = calloc(new_size, sizeof(*new_string));
    _tcscpy(new_string, mystring);

    size_t offset;
    for (offset = sizeof(ULONG_PTR); offset && !((char*)hexval)[offset - 1]; --offset);

    for (size_t i = length ? length : 0, k = offset; k; ++i, --k)
        new_string[i] = ((char*)hexval)[k - 1];

    _tprintf(_T("\"%s\"\n"), new_string);
    free(new_string);
}

Maintaining ANSI-support in 2019 is masochism, though.

How to concatenate an hex to a string in C

2 Answers2