The reason why this is happening is that chars on your system are signed. When you pass them to functions with variable number of arguments, such as printf (outside of fixed-argument portion of the signature) chars get converted to int, and they get sign-extended in the process.

To fix this, cast the value to unsigned char:

printf("\\%02hhx", (unsigned char) pt->GUID[i]);

Demo.

You are seeing the ffffff because char is signed on your system. In C, vararg functions such as printf will promote all integers smaller than int to int. Since char is an integer (8-bit signed integer in your case), your chars are being promoted to int via sign-extension.

Since c0 and 80 have a leading 1-bit (and are negative as an 8-bit integer), they are being sign-extended while the others in your sample don't.

char    int
c0 -> ffffffc0
80 -> ffffff80
61 -> 00000061

Here's a solution:

char ch = 0xC0;
printf("%x", ch & 0xff);

This will mask out the upper bits and keep only the lower 8 bits that you want.

In printf in the bash manual, you'll find:

Arguments to non-string format specifiers are treated as C language constants, except that a leading plus or minus sign is allowed, and if the leading character is a single or double quote, the value is the ASCII value of the following character.

(my emphasis)

These shell functions encapsulate char_to_hex and hex_to_char. Function names stolen from perl

# ord: the ascii value of a character
# $ ord "A" #=> 65
#
ord() {
    printf "%d" "\"$1"
}

# chr: the character represented by the given ASCII decimal value
# $ chr 65 #=> A
#
chr() {
    printf "\x$(printf "%x" "$1")"
}

Then:

 printf '%02X\n' "$(ord A)"
41

If you want to go from the character code to the character itself, you include the character code in the printf format string, escaped with a backslash, in octal.

E.g. printf "\044\n" prints $ (and a newline).

In Bash and other shells, you could use hex, \x24, but that's not standard and doesn't work in Dash.

You could nest another printf in a command substitution to convert from hex or decimal to octal, though. Both of these would print $ (and a newline):

printf "\\$(printf %o 36)\n"
printf "\\$(printf %o 0x24)\n"

You are confused about the fuctionality of strtol. If you have a string that represents a number in hex, you can use strtol like you have:

char s[] = "ff2d";
int n = strtol(s, NULL, 16);
printf("Number: %d\n", n);

When you want to print the characters of a string in hex, use %x format specifier for each character of the string.

char s[] = "Hello";
char* cp = s;
for ( ; *cp != '\0'; ++cp )
{
   printf("%02x", *cp);
}

This:

printf("%x", array);

will most likely print the address of the first element of your array in hexadecimal. I say "most likely" because the behavior of attempting to print an address as if it were an unsigned int is undefined. If you really wanted to print the address, the right way to do it would be:

printf("%p", (void*)array);

(An array expression, in most contexts, is implicitly converted to ("decays" to) a pointer to the array's first element.)

If you want to print each element of your array, you'll have to do so explicitly. The "%s" format takes a pointer to the first character of a string and tells printf to iterate over the string, printing each character. There is no format that does that kind of thing in hexadecimal, so you'll have to do it yourself.

For example, given:

unsigned char arr[8];

you can print element 5 like this:

printf("0x%x", arr[5]);

or, if you want a leading zero:

printf("0x%02x", arr[5]);

The "%x" format requires an unsigned int argument, and the unsigned char value you're passing is implicitly promoted to unsigned int, so this is type-correct. You can use "%x" to print the hex digits a throughf in lower case, "%X" for upper case (you used both in your example).

(Note that the "0x%02x" format works best if bytes are 8 bits; that's not guaranteed, but it's almost certainly the case on any system you're likely to use.)

I'll leave it to you to write the appropriate loop and decide how to delimit the output.

The # part gives you a 0x in the output string. The 0 and the x count against your "8" characters listed in the 08 part. You need to ask for 10 characters if you want it to be the same.

int i = 7;

printf("%#010x\n", i);  // gives 0x00000007
printf("0x%08x\n", i);  // gives 0x00000007
printf("%#08x\n", i);   // gives 0x000007

Also changing the case of x, affects the casing of the outputted characters.

printf("%04x", 4779); // gives 12ab
printf("%04X", 4779); // gives 12AB