C - Pointer offset unexpected

I have a pointer to an array and I'm wanting to use functions like memcpy with a specific offset, however when offsetting the pointer address I'm getting a value that is more than the offset and I don't understand why. Can someone explain what is going on here?

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

int main()
{
    uint8_t *source[5];

    // Initial
    printf("%p\n", (void *)source); // 786796896

    // Offset by 2
    printf("%p\n", (void *)(source + 2)); // 786796912 (unexpected, more than 2)
}

The issue here is when you add 2 to source, the array decays into a pointer type uint8_t **. When you perform arithmetic on a pointer, the offset added is the number of elements added and not the number of bytes if the size of the pointer element is bigger than a byte. The offset in bytes from source + 2 is actually 2*sizeof(*source) bytes, which is 16.

To bypass this behavior, cast source to a char *, perform the addition, then cast back. Be warned however, that doing that incorrectly can result in an unaligned access which can be bad news.

Pointer Arthimetics need to be avoided as much as you can. For above

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

int main() {
    uint8_t* source[5]; // array of 5 pointers of uint8_t* type

    printf("%p\n", &source[2]); // address of 3rd element place in array source
}

A very important point to note is it, adding 2 into source address not results in incrementing address by +2 but by +10 cause 2 was interpreted as char* [5] not char *.

// using without casting
char * arr[5];
char * parr = malloc(sizeof(int));
    
printf("%p\t%p\n", arr, parr);
printf("%p\t%p\n", arr+2, parr+2);

0x7ffde2925fb0  0x55b519f252a0
 +10             +2
0x7ffde2925fc0  0x55b519f252a2

//using with casting

char * arr[5];
char * parr = malloc(sizeof(int));
    
printf("%p\t%p\n", arr, parr);
printf("%p\t%p\n", (void*)arr+2, parr+2);

0x7ffde2925fb0  0x55b519f252a0
 +2               +2
0x7ffde2925fb2  0x55b519f252a2

> I have a pointer to an array

    uint8_t *source[5];

Sorry, but this is not a pointer to an array. It is an array of 5 pointers to uint8_t, uninitialized, so you should initialize it.

This is a pointer to an array:

    uint8_t (*source)[5];

(precedence of [] operator is higher than that of * in type expressions)

> ...what is going on here?

well, based on your wrong assumption, everything is expected to be incorrect.

    // Initial
    printf("%p\n", (void *)source); // 786796896

    // Offset by 2
    printf("%p\n", (void *)(source + 2)); // 786796912 (unexpected, more than 2)

source + 2 is the address of the third array element of array source which is an array of pointers, so it's two pointer places offset from source itself (this is 16 bytes in 64bit architectures --the value you get--, and 8 bytes in 32bit architectures)

Just try with the declaration proposed, and you will get what you expect.

$ a.out
0x560bee9df060
0x560bee9df06a
$ _

(10 positions, as expected for two 5 uint8_t element arrays)

But you can check this yourself.

If you use the sizeof operator on source itself, you will get the size of an array (5 pointers, or 40 bytes, on 64bit arch) while as you state in your question, it should be the size of a single pointer (8 bytes, in 64bit arch) If you declare it with the proposed declaration, then you will get 8 as it should be expetec, while if you do a sizeof *source (the size of the object pointed to by source), in this case you will get 5 (the size of an array of five uint8_t values) Try it and see it.

Final note about the alignment discussion handled in the comments to the question.

1. The declared object was an array of pointers, and not a pointer to an array of five uint8_ts, so its address (the value passed to printf it's indeed aligned and valid (it's indeed the address in the stack where the variable source has been created), and no U.B. is incurred on using that address, because the array contents are not used themselves, so it remains uninitialized and provokes no U.B.)
2. If declared correctly as an pointer to an array, its uninitialized value is printed ---the only unpredictable thing is the value itself---, but that doesn't require to dereference the pointer or alignment (which is not an issue, see next). Pointer arithmetic, in this case should be avoided for uninitialized pointer variable, as it is not warranted that the destination value of the pointer can be a valid address, and so there's some, not harmful normally, U.B. (this is because the original uninitialized value can also be an invalid address itself, and should not cause a U.B. while just being uninitialized. The (void *) cast, by itself, normally doesn't cause any U.B.)
3. If declared as a pointer to an array, again, there's no alignment problem, as the base type of the pointer is an array of uint8_ts which has alignment of 1 (one) and so, any address should be acceptable. As the pointer is not dereferenced, it behaves as any uninitialized variable, and so, it doesn't cause U.B.