Introduction to Pointers

Two operators are fundamental to working with pointers: the address-of operator & which gives you a variable's memory address, and the dereference operator * which lets you access the value at an address. These two operators are opposites - one gets the address, the other follows it to get the value.

The Address-of Operator (&)

The ampersand & placed before a variable returns its memory address. This is how you make a pointer "point to" something - you assign it the address of a variable. Without this operator, a pointer would have no valid address to store.

#include <stdio.h>

int main() {
    int age = 25;
    int *ptr = &age;  // ptr now holds the address of age
    
    printf("Value of age: %d\n", age);        // 25
    printf("Address of age: %p\n", &age);     // 0x7ffd... (some hex address)
    printf("Value stored in ptr: %p\n", ptr); // Same address as above
    
    return 0;
}

This program shows how to use the address-of operator (&) to get a variable's memory address and store it in a pointer. The %p format specifier prints addresses in hexadecimal.

The Dereference Operator (*)

The asterisk * used before a pointer (after declaration) is called the dereference operator. It "follows" the address stored in the pointer and gives you access to the value at that location. You can both read and write values through a dereferenced pointer.

Think of it this way: if a pointer is the address of a house, dereferencing is going to that address and looking inside the house. You can see what's there or change what's inside.

#include <stdio.h>

int main() {
    int score = 100;
    int *ptr = &score;
    
    // Reading through the pointer (dereferencing)
    printf("Value at address %p: %d\n", ptr, *ptr);  // 100
    
    // Writing through the pointer (modifying original variable!)
    *ptr = 200;
    printf("score is now: %d\n", score);  // 200 - changed!
    
    // The pointer and original variable share the same memory
    score = 300;
    printf("*ptr is now: %d\n", *ptr);    // 300 - also changed!
    
    return 0;
}

This program demonstrates the dereference operator (*) which accesses the value at a pointer's address. Changes made through the pointer affect the original variable since they share the same memory location.

Complete Example: Swapping Values

One of the most classic pointer examples is swapping two variables. Without pointers, a swap function cannot modify the original variables because C passes arguments by value. With pointers, the function receives the addresses and can modify the original data.

#include <stdio.h>

// Without pointers - DOES NOT WORK
void badSwap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
    // Only swaps local copies, originals unchanged!
}

// With pointers - WORKS CORRECTLY
void swap(int *a, int *b) {
    int temp = *a;  // Get value at address a
    *a = *b;        // Put value at b into location a
    *b = temp;      // Put temp into location b
}

int main() {
    int x = 10, y = 20;
    
    printf("Before: x = %d, y = %d\n", x, y);  // x=10, y=20
    
    badSwap(x, y);
    printf("After badSwap: x = %d, y = %d\n", x, y);  // Still x=10, y=20
    
    swap(&x, &y);  // Pass addresses!
    printf("After swap: x = %d, y = %d\n", x, y);  // x=20, y=10
    
    return 0;
}

This classic example compares pass-by-value vs pass-by-pointer. The badSwap function fails because it only modifies copies, while swap works correctly by using pointers to access and modify the original variables.

#include <stdio.h>

int main() {
    float price = 19.99;
    float *ptr = &price;
    
    printf("Value: %.2f\n", price);       // 19.99
    printf("Address: %p\n", (void*)&price);  // 0x...
    printf("Via pointer: %.2f\n", *ptr);  // 19.99
    
    return 0;
}

#include <stdio.h>

int main() {
    int count = 5;
    int *ptr = &count;
    
    printf("Before: %d\n", count);  // 5
    
    *ptr = *ptr * 2;  // Or: *ptr *= 2;
    
    printf("After: %d\n", count);   // 10
    
    return 0;
}

#include <stdio.h>

void addToValue(int *num, int amount) {
    *num += amount;  // Dereference and add
}

int main() {
    int balance = 100;
    
    printf("Balance: %d\n", balance);  // 100
    
    addToValue(&balance, 50);
    printf("After deposit: %d\n", balance);  // 150
    
    addToValue(&balance, -30);
    printf("After withdrawal: %d\n", balance);  // 120
    
    return 0;
}

In C, arrays and pointers are deeply connected. An array name is essentially a pointer to its first element, and you can use pointer notation to access array elements. Understanding this relationship is key to mastering both concepts and writing efficient C code.

Array Name as a Pointer

When you declare an array like int numbers[5];, the name numbers represents the memory address of the first element. You can assign this to a pointer without using the & operator because the array name already evaluates to an address.

#include <stdio.h>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    int *ptr = numbers;  // No & needed! Array name is already an address
    
    // These are all equivalent ways to get the first element:
    printf("%d\n", numbers[0]);  // 10 - array notation
    printf("%d\n", *numbers);    // 10 - pointer dereference
    printf("%d\n", *ptr);        // 10 - pointer variable
    printf("%d\n", ptr[0]);      // 10 - pointer with array notation
    
    return 0;
}

This program shows that an array name acts as a pointer to its first element. All four printf statements access the same value using different but equivalent syntax.

Accessing Array Elements with Pointers

Once you have a pointer to an array (or to its first element), you can access any element using pointer arithmetic or array notation. The expression ptr[i] is exactly equivalent to *(ptr + i). C automatically scales the offset by the size of the data type.

#include <stdio.h>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    int *ptr = numbers;
    
    // Array notation vs pointer arithmetic - both work!
    for (int i = 0; i < 5; i++) {
        printf("numbers[%d] = %d, *(ptr+%d) = %d\n", 
               i, numbers[i], i, *(ptr + i));
    }
    
    // Output:
    // numbers[0] = 10, *(ptr+0) = 10
    // numbers[1] = 20, *(ptr+1) = 20
    // numbers[2] = 30, *(ptr+2) = 30
    // numbers[3] = 40, *(ptr+3) = 40
    // numbers[4] = 50, *(ptr+4) = 50
    
    return 0;
}

This code demonstrates that array indexing (numbers[i]) and pointer arithmetic (*(ptr + i)) are equivalent ways to access array elements. C automatically scales the pointer offset by the element size.

Pointer to Specific Array Element

You can create a pointer to any element in an array, not just the first one. Use the & operator with array indexing to get the address of a specific element.

#include <stdio.h>

int main() {
    int data[5] = {100, 200, 300, 400, 500};
    
    int *first = &data[0];   // Points to first element (same as 'data')
    int *third = &data[2];   // Points to third element (300)
    int *last = &data[4];    // Points to last element (500)
    
    printf("First: %d\n", *first);   // 100
    printf("Third: %d\n", *third);   // 300
    printf("Last: %d\n", *last);     // 500
    
    // You can still use array notation with these pointers
    printf("Element after third: %d\n", third[1]);  // 400
    
    return 0;
}

This example shows how to create pointers to specific array elements using the address-of operator with array indexing. Once you have a pointer to an element, you can use array notation relative to that position.

#include <stdio.h>

int main() {
    char letters[4] = {'A', 'B', 'C', 'D'};
    char *ptr = letters;
    
    for (int i = 0; i < 4; i++) {
        printf("%c ", *(ptr + i));  // A B C D
    }
    printf("\n");
    
    return 0;
}

#include <stdio.h>

int sumArray(int *arr, int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += *(arr + i);  // Pointer arithmetic
    }
    return sum;
}

int main() {
    int nums[] = {1, 2, 3, 4, 5};
    int total = sumArray(nums, 5);
    printf("Sum: %d\n", total);  // 15
    return 0;
}

#include <stdio.h>

void reverse(int *arr, int size) {
    int *start = arr;
    int *end = arr + size - 1;
    
    while (start < end) {
        // Swap values at start and end
        int temp = *start;
        *start = *end;
        *end = temp;
        
        start++;  // Move start forward
        end--;    // Move end backward
    }
}

int main() {
    int nums[] = {1, 2, 3, 4, 5};
    int size = 5;
    
    printf("Before: ");
    for (int i = 0; i < size; i++) printf("%d ", nums[i]);
    
    reverse(nums, size);
    
    printf("\nAfter:  ");
    for (int i = 0; i < size; i++) printf("%d ", nums[i]);
    // Output: 5 4 3 2 1
    
    return 0;
}

Pointer arithmetic lets you move pointers forward or backward in memory. When you add 1 to a pointer, it moves forward by the size of the data type it points to. This is incredibly useful for traversing arrays and working with consecutive memory locations.

Incrementing and Decrementing Pointers

When you increment a pointer (ptr++), it moves to the next element, not the next byte. For an int* on a system where int is 4 bytes, incrementing adds 4 to the address. C handles this scaling automatically based on the pointer type.

#include <stdio.h>

int main() {
    int numbers[] = {10, 20, 30, 40, 50};
    int *ptr = numbers;
    
    printf("ptr points to: %d (address: %p)\n", *ptr, (void*)ptr);
    
    ptr++;  // Move to next integer (adds 4 bytes on most systems)
    printf("After ptr++: %d (address: %p)\n", *ptr, (void*)ptr);
    
    ptr += 2;  // Skip 2 integers forward
    printf("After ptr+=2: %d (address: %p)\n", *ptr, (void*)ptr);
    
    ptr--;  // Move back one integer
    printf("After ptr--: %d (address: %p)\n", *ptr, (void*)ptr);
    
    return 0;
}

This program demonstrates pointer increment and decrement operations. Each ++ or -- moves the pointer by the size of the data type (4 bytes for int), not just one byte.

Sample output (addresses will vary):

ptr points to: 10 (address: 0x7ffc1234)
After ptr++: 20 (address: 0x7ffc1238)
After ptr+=2: 40 (address: 0x7ffc1240)
After ptr--: 30 (address: 0x7ffc123c)

Pointer Subtraction

You can subtract two pointers of the same type to find out how many elements are between them. This is useful for determining array positions or calculating distances.

#include <stdio.h>

int main() {
    int arr[] = {100, 200, 300, 400, 500};
    int *start = &arr[0];
    int *end = &arr[4];
    
    // Difference gives number of elements between
    long diff = end - start;
    printf("Elements between start and end: %ld\n", diff);  // 4
    
    // Find index of a value
    int *found = &arr[2];  // Pointer to 300
    printf("Index of 300: %ld\n", found - arr);  // 2
    
    return 0;
}

Subtracting two pointers of the same type gives the number of elements between them, not the byte difference. This is useful for calculating array indices or measuring distances in arrays.

Traversing with Pointers

A common pattern is to use a pointer to walk through an array. You can either use a counter with pointer arithmetic, or compare pointers directly to know when you've reached the end.

#include <stdio.h>

int main() {
    int data[] = {1, 2, 3, 4, 5};
    int size = 5;
    
    // Method 1: Counter with pointer increment
    int *ptr = data;
    printf("Method 1: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", *ptr);
        ptr++;
    }
    printf("\n");
    
    // Method 2: Pointer comparison
    int *end = data + size;  // One past the last element
    printf("Method 2: ");
    for (int *p = data; p < end; p++) {
        printf("%d ", *p);
    }
    printf("\n");
    
    return 0;
}

Two common patterns for traversing arrays with pointers: using a counter with pointer increment, or comparing pointers directly to detect the end. Both methods are widely used in C programming.

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50, 60};
    int size = 6;
    int *end = arr + size;
    
    for (int *p = arr; p < end; p += 2) {
        printf("%d ", *p);  // 10 30 50
    }
    printf("\n");
    
    return 0;
}

#include <stdio.h>

int findIndex(int *arr, int size, int target) {
    int *end = arr + size;
    for (int *p = arr; p < end; p++) {
        if (*p == target) {
            return p - arr;  // Pointer subtraction gives index
        }
    }
    return -1;  // Not found
}

int main() {
    int nums[] = {5, 10, 15, 20, 25};
    
    printf("Index of 15: %d\n", findIndex(nums, 5, 15));  // 2
    printf("Index of 100: %d\n", findIndex(nums, 5, 100)); // -1
    
    return 0;
}

#include <stdio.h>

void copyArray(int *dest, int *src, int size) {
    int *srcEnd = src + size;
    while (src < srcEnd) {
        *dest = *src;
        dest++;
        src++;
    }
    // Or even shorter: while (src < srcEnd) *dest++ = *src++;
}

int main() {
    int original[] = {1, 2, 3, 4, 5};
    int copy[5];
    
    copyArray(copy, original, 5);
    
    printf("Copy: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", copy[i]);  // 1 2 3 4 5
    }
    printf("\n");
    
    return 0;
}

Pointers become essential when working with functions. Since C passes arguments by value, a function cannot directly modify its caller's variables unless it receives pointers to them. This is how functions return multiple values or modify data in place.

Pass by Value vs Pass by Pointer

When you pass a regular variable to a function, C creates a copy. Changes to that copy don't affect the original. When you pass a pointer, the function receives the address and can modify the original variable through that address.

#include <stdio.h>

// Pass by value - cannot modify original
void tryToDouble(int x) {
    x = x * 2;
    printf("Inside tryToDouble: x = %d\n", x);
}

// Pass by pointer - CAN modify original
void doubleIt(int *x) {
    *x = *x * 2;
    printf("Inside doubleIt: *x = %d\n", *x);
}

int main() {
    int num = 5;
    
    tryToDouble(num);
    printf("After tryToDouble: num = %d\n\n", num);  // Still 5
    
    doubleIt(&num);
    printf("After doubleIt: num = %d\n", num);  // Now 10
    
    return 0;
}

This comparison shows that pass-by-value only modifies a local copy while pass-by-pointer modifies the original variable. Use pointers when you need a function to change the caller's data.

Returning Multiple Values

A C function can only return one value. But by accepting pointer parameters, a function can effectively "return" multiple values by modifying the pointed-to locations.

#include <stdio.h>

// Calculate both quotient and remainder
void divide(int dividend, int divisor, int *quotient, int *remainder) {
    *quotient = dividend / divisor;
    *remainder = dividend % divisor;
}

int main() {
    int q, r;
    
    divide(17, 5, &q, &r);
    
    printf("17 / 5 = %d remainder %d\n", q, r);  // 3 remainder 2
    
    return 0;
}

Since C functions can only return one value, pointers allow you to "return" multiple values by writing to locations provided by the caller. Here the divide function returns both quotient and remainder.

Arrays as Function Parameters

When you pass an array to a function, C actually passes a pointer to the first element. That's why array parameters can be declared either as arrays or pointers - they're equivalent. This also means the function can modify the original array!

Method 1: Array Notation

void printArray1(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

This function uses traditional array notation with square brackets. The parameter int arr[] indicates we expect an array, but C actually receives a pointer to the first element.

Method 2: Pointer Notation

void printArray2(int *arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", *(arr + i));
    }
    printf("\n");
}

This function uses explicit pointer notation. The parameter int *arr makes it clear we're receiving a pointer. We access elements using pointer arithmetic with *(arr + i).

Modifying Arrays Through Pointers

void doubleArray(int *arr, int size) {
    for (int i = 0; i < size; i++) {
        arr[i] *= 2;  // Modifies original array!
    }
}

Since arrays are passed as pointers, any changes made inside the function affect the original array. This function doubles each element in place - no return value needed.

Using the Functions

int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    
    printArray1(numbers, 5);  // Output: 1 2 3 4 5
    
    doubleArray(numbers, 5);
    printArray2(numbers, 5);  // Output: 2 4 6 8 10
    
    return 0;
}

When calling these functions, just pass the array name (which decays to a pointer) and the size. After doubleArray modifies the array, printArray2 shows the doubled values.

#include <stdio.h>

void increment(int *n) {
    (*n)++;  // Or: *n = *n + 1;
}

int main() {
    int counter = 10;
    printf("Before: %d\n", counter);  // 10
    
    increment(&counter);
    printf("After: %d\n", counter);   // 11
    
    return 0;
}

#include <stdio.h>

void findMinMax(int *arr, int size, int *min, int *max) {
    *min = arr[0];
    *max = arr[0];
    
    for (int i = 1; i < size; i++) {
        if (arr[i] < *min) *min = arr[i];
        if (arr[i] > *max) *max = arr[i];
    }
}

int main() {
    int data[] = {3, 7, 1, 9, 4, 6, 2};
    int minimum, maximum;
    
    findMinMax(data, 7, &minimum, &maximum);
    
    printf("Min: %d, Max: %d\n", minimum, maximum);  // Min: 1, Max: 9
    
    return 0;
}

#include <stdio.h>

void partition(int *arr, int size, int pivot, int *partitionIndex) {
    int writeIndex = 0;
    
    // Move smaller elements to the front
    for (int i = 0; i < size; i++) {
        if (arr[i] < pivot) {
            // Swap arr[i] and arr[writeIndex]
            int temp = arr[i];
            arr[i] = arr[writeIndex];
            arr[writeIndex] = temp;
            writeIndex++;
        }
    }
    
    *partitionIndex = writeIndex;
}

int main() {
    int data[] = {5, 2, 8, 1, 9, 3, 7};
    int size = 7;
    int partIdx;
    
    printf("Before: ");
    for (int i = 0; i < size; i++) printf("%d ", data[i]);
    
    partition(data, size, 5, &partIdx);
    
    printf("\nAfter (pivot=5): ");
    for (int i = 0; i < size; i++) printf("%d ", data[i]);
    printf("\nPartition at index: %d\n", partIdx);
    
    return 0;
}

Pointers are powerful but can cause subtle and dangerous bugs. Understanding common mistakes will help you write safer code and debug pointer-related issues when they occur. These errors often lead to crashes, data corruption, or security vulnerabilities.

Uninitialized Pointers

A pointer that hasn't been assigned a valid address contains garbage - it could point anywhere in memory. Dereferencing such a pointer leads to undefined behavior, which might crash your program or silently corrupt data.

// DANGEROUS: Uninitialized pointer
int *ptr;        // ptr contains garbage address
*ptr = 42;       // Writing to random memory - undefined behavior!

// SAFE: Initialize to NULL or a valid address
int *ptr1 = NULL;        // Explicitly not pointing to anything
int value = 10;
int *ptr2 = &value;      // Points to a valid variable

Uninitialized pointers contain garbage values and point to random memory locations. Always initialize pointers to NULL or a valid address to prevent undefined behavior and crashes.

NULL Pointer Dereference

A NULL pointer explicitly points to "nothing". Attempting to dereference it causes a crash (segmentation fault). Always check for NULL before dereferencing, especially for pointers that might come from functions or user input.

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

int main() {
    int *ptr = NULL;
    
    // DANGEROUS: Dereference without checking
    // printf("%d\n", *ptr);  // Crash!
    
    // SAFE: Check before using
    if (ptr != NULL) {
        printf("%d\n", *ptr);
    } else {
        printf("Pointer is NULL - cannot dereference\n");
    }
    
    return 0;
}

Always check if a pointer is NULL before dereferencing it. Dereferencing NULL causes a segmentation fault and crashes your program. This is especially important for pointers returned from functions.

Dangling Pointers

A dangling pointer points to memory that has been freed or a variable that no longer exists (like a local variable after a function returns). Using a dangling pointer is undefined behavior.

#include <stdio.h>

// DANGEROUS: Returning pointer to local variable
int* badFunction() {
    int localVar = 42;
    return &localVar;  // localVar disappears when function returns!
}

int main() {
    int *ptr = badFunction();
    // ptr is now dangling - localVar no longer exists
    // *ptr is undefined behavior!
    
    return 0;
}

A dangling pointer points to memory that no longer exists (like a local variable after its function returns). Never return addresses of local variables - use dynamic allocation or output parameters instead.

Array Out of Bounds

When using pointers with arrays, going past the array bounds reads or writes arbitrary memory. C doesn't check bounds, so these errors silently corrupt data or crash later.

#include <stdio.h>

int main() {
    int arr[3] = {10, 20, 30};
    int *ptr = arr;
    
    // Valid access
    printf("%d\n", *(ptr + 2));  // 30 - last element
    
    // DANGEROUS: Out of bounds
    // printf("%d\n", *(ptr + 5));  // Reading garbage!
    // *(ptr + 10) = 100;           // Writing to random memory!
    
    return 0;
}

C does not perform bounds checking on array or pointer access. Accessing memory outside array bounds causes undefined behavior - always track array sizes and validate indices before access.

Type Mismatch

Assigning a pointer of one type to another (without explicit casting) can lead to misinterpreting data. The compiler usually warns about this, but it's still a common source of bugs.

#include <stdio.h>

int main() {
    int value = 1000;
    int *intPtr = &value;
    
    // DANGEROUS: Type mismatch (compiler may warn)
    // char *charPtr = intPtr;  // Wrong! intPtr is int*
    
    // This would read only 1 byte instead of 4
    // char wrongValue = *charPtr;
    
    // If you must cast, be explicit about it
    char *charPtr = (char*)intPtr;  // Explicit cast - you know what you're doing
    
    return 0;
}

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

// Fix: Give ptr a valid address
int value;
int *ptr = &value;  // Now ptr points to valid memory
*ptr = 100;
printf("%d\n", *ptr);  // Safe: prints 100

#include <stdio.h>

int safeDouble(int *ptr) {
    if (ptr == NULL) {
        return 0;  // Failed - pointer is NULL
    }
    *ptr *= 2;
    return 1;  // Success
}

int main() {
    int value = 5;
    int *ptr1 = &value;
    int *ptr2 = NULL;
    
    if (safeDouble(ptr1)) {
        printf("Doubled: %d\n", value);  // 10
    }
    
    if (!safeDouble(ptr2)) {
        printf("Could not double - NULL pointer\n");
    }
    
    return 0;
}

int* createAndDouble(int value) {
    int result = value * 2;
    return &result;
}

int main() {
    int *doubled = createAndDouble(21);
    printf("Result: %d\n", *doubled);
    return 0;
}

int createAndDouble(int value) {
    return value * 2;
}

int main() {
    int result = createAndDouble(21);
    printf("Result: %d\n", result);  // 42
    return 0;
}

void createAndDouble(int value, int *result) {
    *result = value * 2;
}

int main() {
    int result;
    createAndDouble(21, &result);
    printf("Result: %d\n", result);  // 42
    return 0;
}