是否可以在 C 中下标为 uint64_t 指针？

Question

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?

Answer 1

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.

Answer 2

• 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

Answer 3

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 char s it is OK.

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

    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 = #

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