C Pointers

Key Pointer Concepts

int *ptr;  // Pointer to integer

ptr = &variable  // Get address

int value = *ptr;  // Get value

int *ptr = NULL;  // Safe start

🔹 Basic Pointer Example

Pointers are variables that store memory addresses of other variables, forming the foundation of dynamic programming in C. Declaration syntax uses the asterisk: int *ptr = &variable creates a pointer to an integer. The ampersand (&) operator obtains a variable's address, while the asterisk (*) operator dereferences pointers to access stored values. Understanding pointer basics enables you to manipulate memory directly, create complex data structures, and write efficient algorithms. Pointers are indispensable for mastering C programming.

#include <stdio.h>

int main() {
    int number = 25;
    int *ptr;
    
    ptr = &number  // Store address of number
    
    printf("Value of number: %d\n", number);
    printf("Address of number: %p\n", &number);
    printf("Value of ptr: %p\n", ptr);
    printf("Value pointed by ptr: %d\n", *ptr);
    
    return 0;
}

Value of number: 25
Address of number: 0x7fff5fbff6ac
Value of ptr: 0x7fff5fbff6ac
Value pointed by ptr: 25

🔹 Pointer Arithmetic

Pointer arithmetic enables you to navigate through memory by adding or subtracting integers from pointer values. Operations like ptr++ move the pointer to the next element based on the data type size. For example, incrementing an integer pointer advances by 4 bytes on most systems. Pointer arithmetic is essential for array traversal, string manipulation, and dynamic data structure implementation. However, careful bounds checking prevents memory access violations. Mastering pointer arithmetic unlocks efficient memory manipulation techniques.

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = arr;  // Points to first element
    
    printf("First element: %d\n", *ptr);
    ptr++;  // Move to next element
    printf("Second element: %d\n", *ptr);
    ptr += 2;  // Move 2 positions forward
    printf("Fourth element: %d\n", *ptr);
    
    return 0;
}

First element: 10
Second element: 20
Fourth element: 40

🔹 Common Pointer Mistakes

Avoiding common pointer errors prevents crashes, undefined behavior, and security vulnerabilities in C programs. Frequent mistakes include dereferencing null pointers, accessing uninitialized pointers, and exceeding array bounds. Memory leaks occur when allocated memory is never freed, consuming resources unnecessarily. Wild pointers reference invalid memory locations after deallocation. Always initialize pointers before use, validate pointer values, and implement proper memory management practices. Understanding these pitfalls transforms you into a safer and more competent C programmer.

int *ptr;  // Dangerous - points to random memory
*ptr = 10;  // May crash program

int *ptr = NULL;  // Safe initialization
if (ptr != NULL) {
    *ptr = 10;  // Check before use
}