Is it possible to subscript into a uint64_t pointer in C?

user_13451528 0
Viewed 93

I'm a C beginner. Having trouble understanding whats happening with this code:

#include <stdio.h>
#include <stdint.h>

int main(void)
{
    uint64_t num = 99999;
    uint64_t *num_ptr = &num;

    uint8_t first_byte = ((uint8_t *)num_ptr)[0];

    printf("%hhu", first_byte);

    return 0;
}

This prints 159.

I'm looking at uint8_t first_byte = ((uint8_t *)num_ptr)[0];

I'm trying to understand it this way: the uint64_t pointer num_ptr is first cast as a uint8_t pointer, then we index into it with the square brackets to get the first byte. Is this a correct explanation? If so is it possible to index into pointers to get their partial contents without dereferencing?

pointers indexing casting c
3 Answers

Consider a work-alike program:

#include <stdio.h>
#include <stdint.h>

typedef union td_USixtyFour
{
    uint64_t whole;
    uint8_t  parts[sizeof(uint64_t)];
} USixtyFour;


int main( int argc, char **argv )
{
    USixtyFour number;
    number.whole = 99999;

    printf( "number.parts[0] is %u / 0x%02x\n", number.parts[0], number.parts[0] );

    return 0;
}

Which outputs:

number.parts[0] is 159 / 0x9f

Here with a C union, it's simulating what was done in the OP's code. The .parts covers the same memory as the .whole. So in essence the parts is giving access to the content of the uint64_t's bytes-in-memory without any sort of pointer dereference.

This sort of operation will have issues with portability due to endianness, and should generally be avoided. Of course one could mitigate this by packing into network-byte-order with functions like htonl(), so a known order is preserved.

user_17308950
  • 99999 = 0x1869F or if you will as a 64 bit number 0000 0000 0001 869F
  • Intel/PC computers use little endian. What is CPU endianness?
  • Therefore your 64 bit number is stored in memory as 9F86 0100 0000 0000.
  • C allows us to inspect a larger data type byte by byte through a pointer to a character type. uint8_t is a character type on all non-exotic systems.
  • ((uint8_t *)num_ptr)[0]; Converts the 64 bit pointer to a 8 bit (character) pointer and then uses the [] operator to de-reference that pointer.
  • We get the first byte 0x9F = 159 dec.
  • %hhu is used to print unsigned char. The most correct conversion specifier to use for uint8_t would otherwise be "%" PRIU8 from inttypes.h
user_5845180
  1. What you do is a "pointer punning". Generally it is a dangerous operation, might invoke Undefined Behavior and violate strict aliasing rule. But when you access other data as chars it is OK.
int main(void)
{
    uint64_t num = 99999;
    uint64_t *num_ptr = &num;

    printf("%016"PRIx64"\n", num);

    for(size_t index = 0; index < sizeof(num); index++)
    {
        printf("Index = %2zu, value= %02hhx\n", index, ((unsigned char *)num_ptr)[index]);
    }
    return 0;
}

The safest method is to use memcpy

int main(void)
{
    uint64_t num = 99999;
    uint64_t *num_ptr = &num;

    unsigned char arr[sizeof(num)];

    printf("%016"PRIx64"\n", num);

    memcpy(arr, &num, sizeof(num));

    for(size_t index = 0; index < sizeof(num); index++)
    {
        printf("Index = %2zu, value= %02hhx\n", index, arr[index]);
    }
    return 0;
}
user_61100940
Related