Memory and Addresses

Memory management forms the foundation of pointer understanding. Consider a dormitory building analogy where each room needs identification numbers for efficient location. Without room numbers, visitors would need to search every room sequentially, which is highly inefficient.

In computing, the CPU processes data from memory locations. Computer memory consists of billions of individual storage units, each holding one byte of data. These memory locations require unique identifiers similar to room numbers.

Memory addresses function like these room identifiers. Each byte in memory receives a sequential address starting from zero. This addressing system allows the CPU to locate specific data quickly.

The hardware implements addressing through physical connections. In a 32-bit system, 32 address lines can represent 2^32 unique addresses, requiring 4 bytes to store each address. Similarly, 64-bit systems use 8 bytes per address.

Address Operators and Pointer Variables

In C programming, variables occupy specific memory locations. The address-of operator (&) retrieves the memory address of a variable:

#include <stdio.h>
int main() {
    int value = 42;
    printf("Address of value: %p\n", &value);
    return 0;
}

Pointer variables store memory addresses. They maintain the same address size regardless of the data type they point to:

int main() {
    int number = 100;
    int* pointer_to_number = &number;
    return 0;
}

The pointer variable pointer_to_number holds the address of number. The asterisk (*) in the declaration indicates it's a pointer variable.

Dereferencing and Pointer Operations

The dereference operator (*) accesses the value stored at a pointer's address:

#include <stdio.h>
int main() {
    int target = 200;
    int* access_point = &target;
    *access_point = 0;  // Modifies the value at target's address
    return 0;
}

Here, *access_point = 0 changes the value stored at the address held by access_point, effectively modifying target.

Pointer Type Significance

Pointer types determine how many bytes are accessed during dereferencing operations:

#include <stdio.h>
int main() {
    int integer_value = 0x11223344;
    int* int_ptr = &integer_value;
    char* char_ptr = (char*)&integer_value;
    
    *int_ptr = 0;     // Clears all 4 bytes
    *char_ptr = 0;    // Clears only 1 byte
    return 0;
}

When incrementing pointers, the step size depends on the pointer's data type:

int sample = 0x11223344;
int* int_location = &sample;
char* char_location = (char*)&sample;

printf("int pointer: %p, next: %p\n", int_location, int_location + 1);
printf("char pointer: %p, next: %p\n", char_location, char_location + 1);

Integer pointers advance by 4 bytes, while character pointers advance by 1 byte.

Array Access Using Pointers

Arrays and pointers work closely together. Array names typically represent the address of the first element:

int main() {
    int collection[] = {10, 20, 30, 40, 50};
    int* tracker = collection;  // Same as &collection[0]
    
    for (int index = 0; index < 5; index++) {
        printf("Element %d: %d\n", index, *(tracker + index));
    }
    return 0;
}

Both collection[index] and *(tracker + index) access the same memory location.

Const Qualifiers with Pointers

The const keyword provides different protection mechanisms:

int main() {
    int mutable_var = 50;
    int immutable_var = 75;
    
    const int* restrict_data = &immutable_var;  // Data cannot be modified
    int* const fixed_address = &mutable_var;    // Address cannot be changed
    
    // *restrict_data = 100;  // Invalid - data is protected
    // fixed_address = &other; // Invalid - address is fixed
    return 0;
}

When const appears before the asterisk, the pointed-to data becomes read-only. When it appears after the asterisk, the pointer address becomes fixed.

Pointer Arithmetic Operations

Pointers support arithmetic operations:

• Adding an integer moves the pointer forward by that many elements
• Subtracting two pointers yields the distance between them
• Comparing pointers determines their relative positions

#include <stdio.h>
int my_strlen(char* start) {
    char* end = start;
    while (*end != '\0') {
        end++;
    }
    return end - start;
}

Dangling Pointers

Dangling pointers reference invalid memory locations. Common causes include:

• Uninitialized pointers containing random values
• Pointers accessing beyond array boundaries
• Pointers referencing freed memory

#include <stdio.h>
int* problematic_function() {
    int local_value = 100;
    return &local_value;  // Dangerous - returns address of destroyed variable
}

Preventing Dangling Pointers

Initialize pointers properly:

int main() {
    int actual_data = 25;
    int* safe_pointer = &actual_data;  // Proper initialization
    int* uninitialized = NULL;         // Explicit null initialization
    
    // Before using a pointer, verify it's valid
    if (safe_pointer != NULL) {
        *safe_pointer = 30;
    }
    return 0;
}

Function Calls: Value vs Reference

Value passing creates copies of arguments:

void swap_values(int first, int second) {
    int temporary = first;
    first = second;
    second = temporary;
    // Original variables remain unchanged
}

Reference passing uses pointers to modify original variables:

void swap_references(int* first_ptr, int* second_ptr) {
    int temporary = *first_ptr;
    *first_ptr = *second_ptr;
    *second_ptr = temporary;
    // Original variables are modified
}

Multi-level Pointers

Pointers can reference other pointers:

int main() {
    int base_value = 10;
    int* level_one = &base_value;
    int** level_two = &level_one;
    int*** level_three = &level_two;
    
    ***level_three = 20;  // Modifies base_value
    return 0;
}

Pointer Arrays

Arrays can store multiple pointers:

int main() {
    int item_a = 1, item_b = 2, item_c = 3;
    int* collection[3] = {&item_a, &item_b, &item_c};
    
    for (int i = 0; i < 3; i++) {
        printf("Value: %d\n", *collection[i]);
    }
    return 0;
}

Function Pointers

Functions have addresses and can be referenced by pointers:

int calculate_sum(int x, int y) {
    return x + y;
}

int main() {
    int (*function_pointer)(int, int) = calculate_sum;
    int result = function_pointer(5, 7);  // Calls the function
    return 0;
}

Function Pointer Arays

Multiple function pointers can be stored in arrays:

int add_operation(int a, int b) { return a + b; }
int multiply_operation(int a, int b) { return a * b; }

int main() {
    int (*operations[])(int, int) = {add_operation, multiply_operation};
    int sum_result = operations[0](10, 5);
    int product_result = operations[1](10, 5);
    return 0;
}

Callback Functions

Callback functions are passed as arguments to other functions:

void execute_with_callback(int value, void (*callback)(int)) {
    callback(value);
}

void display_value(int val) {
    printf("Received: %d\n", val);
}

int main() {
    execute_with_callback(42, display_value);
    return 0;
}

Standard Library qsort Function

The qsort function demonstrates advanced pointer usage:

#include <stdlib.h>

int compare_integers(const void* first, const void* second) {
    int a = *(const int*)first;
    int b = *(const int*)second;
    return (a > b) - (a < b);
}

int main() {
    int data[] = {64, 34, 25, 12, 22, 11, 90};
    int count = sizeof(data) / sizeof(data[0]);
    
    qsort(data, count, sizeof(int), compare_integers);
    return 0;
}

Size Calculations: sizeof vs strlen

sizeof operates at compile time and returns memory size:

int main() {
    char text[] = "Hello";
    printf("Array size: %zu bytes\n", sizeof(text));  // Includes null terminator
    printf("String length: %zu characters\n", strlen(text));  // Excludes terminator
    return 0;
}

strlen counts characters until encountering the null terminator at runtime.