Pointers &
Dynamic Memory

int age = 25;        /* normal variable, holds a value      */
int *ptr = &age;     /* pointer, holds age's ADDRESS         */

int    *ptr;     /* pointer to int    */
char   *ch;      /* pointer to char   */
float  *fp;      /* pointer to float  */
double *dp;      /* pointer to double */

/* Correct initialization */
int x = 10;
int *p = &x;     /* p stores the address of x */

/* WRONG: dereferencing before initialization */
int *bad;
/* *bad = 10;  ← undefined behaviour! bad is uninitialized */

#include <stdio.h>

int main()
{
    int x = 50;

    printf("%p\n", (void *)&x);   /* always cast to (void*) for %p */

    return 0;
}

#include <stdio.h>

int main()
{
    int x = 25;
    int *ptr = &x;

    printf("%d\n", *ptr);    /* 25 — value AT the address ptr holds */

    *ptr = 50;                /* modifies x through the pointer      */
    printf("%d\n", x);        /* 50 — original variable changed!     */

    return 0;
}

int num = 100;
int *ptr = #

int arr[3] = {10, 20, 30};
int *ptr = arr;            /* ptr points to arr[0], say at 0x1000 */

printf("%p\n", (void*)ptr);   /* 0x1000 */
ptr++;                          /* moves by sizeof(int) = 4 bytes! */
printf("%p\n", (void*)ptr);   /* 0x1004, NOT 0x1001 */

int arr[10];
int *p1 = &arr[2];
int *p2 = &arr[7];

printf("%td", p2 - p1);   /* 5 — number of ELEMENTS, not bytes */

int numbers[5] = {10, 20, 30, 40, 50};

int *ptr = numbers;        /* equivalent to &numbers[0] */

printf("%p\n", (void*)numbers);       /* same address */
printf("%p\n", (void*)&numbers[0]);   /* same address */
/* numbers and &numbers print the same VALUE, but have different TYPES */

int numbers[5] = {10, 20, 30, 40, 50};

/* Method 1: index notation */
for(int i = 0; i < 5; i++)
    printf("%d ", numbers[i]);

/* Method 2: pointer notation — moves the pointer itself */
int *ptr = numbers;
for(int i = 0; i < 5; i++)
{
    printf("%d ", *ptr);
    ptr++;
}
/* Both print: 10 20 30 40 50 */

/* GPIO register at a fixed hardware address */
volatile unsigned int *GPIO = (volatile unsigned int *)0x40021014;

unsigned int value = *GPIO;   /* read the register  */
*GPIO = 0x01;                  /* write to the register */

#include <stdio.h>

void swap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main()
{
    int x = 10, y = 20;

    swap(&x, &y);

    printf("%d %d\n", x, y);   /* 20 10 */

    return 0;
}

int x = 10;
int *p = &x;        /* p points to x      */
int **pp = &p;       /* pp points to p     */

printf("%d\n", x);     /* 10 */
printf("%d\n", *p);    /* 10 — value at p's address (x) */
printf("%d\n", **pp);  /* 10 — value at pp's address's address */

int a = 10, b = 20;

/* 1. Pointer to constant — value can't change, pointer can */
const int *ptr1 = &a;
ptr1 = &b;       /* OK — pointer can be reassigned   */
/* *ptr1 = 50;      ERROR — value is read-only via ptr1 */

/* 2. Constant pointer — pointer can't change, value can */
int *const ptr2 = &a;
*ptr2 = 99;       /* OK — value can be changed         */
/* ptr2 = &b;       ERROR — pointer itself is fixed     */

/* 3. Constant pointer to constant — neither can change */
const int *const ptr3 = &a;
/* *ptr3 = 1;       ERROR */
/* ptr3 = &b;       ERROR */

/* 4. Plain pointer — both can change (default) */
int *ptr4 = &a;
*ptr4 = 1;        /* OK */
ptr4 = &b;        /* OK */

int x = 50;
void *ptr = &x;    /* void* can hold ANY pointer type */

/* WRONG — compiler has no idea how many bytes to read */
/* printf("%d", *ptr);   ← compile error               */

/* CORRECT — cast to the real type first, then dereference */
printf("%d\n", *(int *)ptr);   /* 50 */

int *ptr;

{
    int x = 10;
    ptr = &x;     /* ptr points to x, valid here */
}
/* x no longer exists — ptr is now dangling! */
/* *ptr = 5;  ← undefined behaviour */

#include <stdlib.h>

void *malloc(size_t size);

/* Allocate one integer */
int *ptr = (int *)malloc(sizeof(int));

if(ptr == NULL)
{
    printf("Memory allocation failed!\n");
    return 1;
}

*ptr = 100;
printf("%d\n", *ptr);    /* 100 */

/* Allocate an array of 5 integers */
int *arr = malloc(5 * sizeof(int));
for(int i = 0; i < 5; i++)
    arr[i] = i * 10;       /* 0 10 20 30 40 */

#include <stdlib.h>

void *calloc(size_t count, size_t size);

int *a = malloc(5 * sizeof(int));   /* indeterminate garbage values */
int *b = calloc(5, sizeof(int));    /* all 5 elements = 0           */

printf("%d\n", b[0]);   /* 0 — guaranteed by calloc */

#include <stdlib.h>

int *arr = malloc(5 * sizeof(int));

/* Unsafe — if realloc fails, you lose the original pointer (leak!) */
/* arr = realloc(arr, 10 * sizeof(int)); */

/* Safe pattern: use a temporary pointer */
int *temp = realloc(arr, 10 * sizeof(int));

if(temp != NULL)
{
    arr = temp;     /* success — update arr only now */
}
else
{
    /* arr is STILL VALID — realloc failure doesn't free the original */
    printf("Resize failed, original data intact\n");
}

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int n;
    printf("Enter size: ");
    scanf("%d", &n);

    int *arr = malloc(n * sizeof(int));
    if(arr == NULL)
        return 1;

    for(int i = 0; i < n; i++)
        scanf("%d", &arr[i]);

    for(int i = 0; i < n; i++)
        printf("%d ", arr[i]);

    free(arr);     /* release the memory */
    arr = NULL;    /* avoid dangling reference */

    return 0;
}

#include <stdio.h>

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }

int main()
{
    /* Declaration: returns int, takes (int,int) */
    int (*operation)(int, int);

    operation = add;
    printf("%d\n", operation(5, 6));    /* 11 */
    printf("%d\n", (*operation)(5, 6)); /* 11 — also valid syntax */

    operation = sub;
    printf("%d\n", operation(10, 4));   /* 6  */

    return 0;
}

void execute(int (*operation)(int, int))
{
    printf("%d\n", operation(5, 10));
}

int main()
{
    execute(add);   /* pass add() as a callback — output: 15 */
    return 0;
}

#include <stdio.h>

int main(int argc, char *argv[])
{
    printf("Argument count: %d\n", argc);

    for(int i = 0; i < argc; i++)
        printf("argv[%d] = %s\n", i, argv[i]);

    return 0;
}

int arr[] = {10, 20, 30};
int *ptr = arr;

printf("%d\n", *ptr++);   /* prints 10, THEN ptr moves to arr[1] */
printf("%d\n", *ptr);     /* prints 20 — ptr already advanced    */

/* GPIO output register */
volatile unsigned int *GPIO = (volatile unsigned int *)0x40021014;
*GPIO |= (1 << 5);     /* set bit 5 — turn LED on */

/* UART data register — read incoming byte */
volatile unsigned char *UART = (volatile unsigned char *)0x40013804;
char data = *UART;

/* ADC data register — read sensor value */
volatile unsigned int *ADC = (volatile unsigned int *)0x4001244C;
unsigned int value = *ADC;

/* Common style: wrap in a macro for readability */
#define GPIO_ODR (*(volatile unsigned int *)0x40021014)
GPIO_ODR |= (1 << 5);