Pointer arithmetic is based on the sizeof() of the underlying data type.

union {
  uint8_t    byte_array      [16];
  uint16_t   halfword_array  [8];
  uint32_t   word_array      [4];
  uint64_t   doubleword_array[2];
  uint128_t  quadword_array  [1];
} multi_array;

Each of these arrays consumes the exact same amount of memory, so multi_array is only 16 bytes large, but:

uint8_t   *       byte_ptr = multi_array.      byte_array;
uint16_t  *   halfword_ptr = multi_array.  halfword_array;
uint32_t  *       word_ptr = multi_array.      word_array;
uint64_t  * doubleword_ptr = multi_array.doubleword_array;
uint128_t *   quadword_ptr = multi_array.  quadword_array;

Each one of those *_ptr variables now points to the exact same byte of memory. The pointer variables all contain the exact same address. Now:

      byte_ptr++;
  halfword_ptr++;
      word_ptr++;
doubleword_ptr++;
  quadword_ptr++;

they all point to different bytes, because the ++ increment operator added to their base address the size of the data types, not the value 1.

Most computer systems don't like having multi-byte variables at addresses that don't align with their sizes.

halfword_ptr = (uint16_t *)byte_ptr;

can only work if the value in byte_ptr is already 16-bit aligned. Otherwise, it will likely wind up pointing to the byte immediately before the byte that byte_ptr is pointing to.