Pointers, Arrays & Memory Layout

#include 

/* Basic pointer: holds an address; dereference to read/write the value */
uint32_t  g_counter = 0u;
uint32_t *p_counter = &g_counter;

void increment_via_pointer(void) {
    (*p_counter)++;               /* dereference and increment */
}

/* Hardware register pointer: always volatile */
#define CAN_MCR  (*(volatile uint32_t *)0xF0200000u)
#define CAN_SR   (*(volatile uint32_t *)0xF0200004u)

void can_enable(void) {
    CAN_MCR &= ~(1u << 0u);      /* clear INIT bit to enable CAN */
    while (CAN_SR & (1u << 11u)) { /* wait for bus off clear */ }
}

/* Function pointer: stores address of a function */
typedef void (*Callback_t)(uint8_t event);
static Callback_t g_rxCallback = NULL;

void Can_RegisterRxCallback(Callback_t cb) { g_rxCallback = cb; }
void Can_RxHandler(uint8_t event) {
    if (g_rxCallback != NULL) { g_rxCallback(event); }
}

#include 

/* Array name = pointer to first element */
uint8_t buf[8] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88};

/* These three are identical: */
uint8_t b1 = buf[3];          /* array index */
uint8_t b2 = *(buf + 3);      /* pointer arithmetic */
uint8_t b3 = *(&buf[0] + 3);  /* explicit base + offset */

/* Pointer difference: number of elements between pointers */
uint8_t *start = &buf[0];
uint8_t *end   = &buf[8];     /* one past last valid element */
ptrdiff_t len  = end - start; /* = 8 (elements, not bytes) */

/* Multi-dimensional array in memory: row-major in C */
uint16_t matrix[3][4];        /* 3 rows × 4 columns */
/* matrix[r][c] == *(*(matrix+r)+c) == *((uint16_t*)matrix + r*4 + c) */

/* Passing array to function: decays to pointer; length must be passed separately */
void process_buffer(const uint8_t *data, uint16_t len)
{
    for (uint16_t i = 0u; i < len; i++) {
        /* process data[i] */
        (void)data[i];
    }
}

#include 

uint32_t  value  = 100u;
uint32_t  other  = 200u;

/* 1. Pointer to non-const: can change pointer AND data */
uint32_t *p1 = &value;
*p1 = 50u;        /* OK: modify data */
p1  = &other;     /* OK: change where pointer points */

/* 2. Pointer to const (read-only data): can change pointer, not data */
const uint32_t *p2 = &value;
/* *p2 = 50u; */  /* COMPILE ERROR: data is const via this pointer */
p2 = &other;      /* OK: can redirect pointer */

/* 3. const pointer to non-const (fixed pointer): can change data, not pointer */
uint32_t * const p3 = &value;
*p3 = 50u;        /* OK */
/* p3 = &other; */ /* COMPILE ERROR: pointer address is fixed */

/* 4. const pointer to const: neither data nor pointer can change */
const uint32_t * const p4 = &value;  /* fully read-only */

/* Hardware register: always use (3) — fixed pointer to volatile */
volatile uint32_t * const GPIO_IN = (volatile uint32_t *)0xF0001000u;