C Pointers - Complete Guide

Introduction to C Pointers

Pointers are variables that store memory addresses rather than actual values. They are one of the most powerful features of C programming, enabling direct memory access, efficient array handling, dynamic memory allocation, and function callbacks.

Basic Pointers - Declaration and Usage

Basic pointers store the memory address of a variable. They are declared using the asterisk (*) symbol and are fundamental to understanding all pointer concepts.

Key Operators:

• & (Address Operator): Returns memory address of a variable
• * (Dereference Operator): Accesses value at stored address
• NULL: Special value indicating pointer points to nothing

Memory Visualization:

Basic Pointer Examples:

#include <stdio.h>

int main(void) {
    int x = 42;
    int *p = &x;
    printf("x = %d, *p = %d\n", x, *p);
    *p = 100;
    printf("after *p=100: x = %d\n", x);
    return 0;
}

#include <stdio.h>

int main(void) {
    int *p = NULL;
    int x = 5;
    if (p != NULL)
        printf("%d\n", *p);
    else
        printf("p is NULL — safe to skip dereference\n");
    p = &x;
    printf("*p = %d\n", *p);
    return 0;
}

Pointer to Arrays - Complete Guide

Array names in C are essentially constant pointers to the first element of the array. Pointers provide efficient ways to traverse and manipulate arrays.

Key Characteristics:

• Array Name as Pointer: arr is equivalent to &arr[0]
• Pointer Arithmetic: ptr + i moves i elements forward
• Indexing: ptr[i] is same as *(ptr + i)
• Multi-dimensional: Pointers can point to 2D/3D arrays
• Bounds Checking: No automatic bounds checking - programmer's responsibility

Memory Visualization:

Array Pointer Examples:

#include <stdio.h>

int main(void) {
    int arr[] = {10, 20, 30};
    int *p = arr;
    printf("%d %d %d\n", *p, *(p+1), *(p+2));
    return 0;
}

#include <stdio.h>

int main(void) {
    int m[2][3] = {{1,2,3}, {4,5,6}};
    printf("%d\n", m[1][2]);
    printf("%d\n", *(*(m+1)+2));
    return 0;
}

Pointer to Strings - Complete Guide

In C, strings are arrays of characters terminated by a null character ('\0'). Pointers provide efficient ways to manipulate strings without copying entire strings.

Key Characteristics:

• String Literals: Stored in read-only memory (cannot be modified)
• Null Termination: Strings end with '\0' character
• Array vs Pointer: Arrays can be modified, string literals cannot
• Standard Functions: strcpy, strlen, strcmp work with pointers
• Pointer Arithmetic: Can traverse strings character by character

String Memory Visualization:

String Pointer Examples:

#include <stdio.h>
#include <string.h>

int main(void) {
    char s[] = "Hello";
    char *p = s;
    while (*p) {
        putchar(*p++);
    }
    putchar('\n');
    printf("len = %zu\n", strlen(s));
    return 0;
}

Function Pointers - Complete Guide

Function pointers store the address of a function, allowing functions to be passed as arguments, returned from functions, and stored in data structures. This enables callbacks and dynamic function dispatch.

Key Characteristics:

• Type Safety: Must match function signature exactly
• Callbacks: Pass functions as arguments to other functions
• Dynamic Dispatch: Choose function at runtime
• Function Tables: Arrays of function pointers for state machines
• qsort: Standard library uses function pointers for comparison

Function Pointer Examples:

#include <stdio.h>

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

int main(void) {
    int (*op)(int, int) = add;
    printf("%d\n", op(5, 3));
    op = sub;
    printf("%d\n", op(5, 3));
    return 0;
}

Pointers as Function Arguments

Passing pointers as function arguments allows functions to modify variables in the caller's scope (pass-by-reference) and is more efficient for large data structures than copying entire structures.

Key Concepts:

• Pass by Reference: Functions can modify original variables
• Efficiency: Avoid copying large structures
• Multiple Returns: Return multiple values via pointers
• Arrays: Arrays are always passed by reference (as pointers)
• Const Correctness: Use const to prevent modification

Pointer Arguments Examples:

#include <stdio.h>

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

int main(void) {
    int x = 3, y = 7;
    swap(&x, &y);
    printf("x=%d y=%d\n", x, y);
    return 0;
}

Dynamic Memory Allocation

Dynamic memory allocation allows programs to request memory at runtime using malloc, calloc, realloc, and free. This is essential for data structures that grow/shrink during execution.

Key Functions Comparison:

Dynamic Memory Examples:

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

int main(void) {
    int *p = (int *)malloc(3 * sizeof(int));
    if (!p) return 1;
    p[0] = 1; p[1] = 2; p[2] = 3;
    printf("%d %d %d\n", p[0], p[1], p[2]);
    free(p);
    return 0;
}

Common Mistakes and Best Practices