CodeToLive

Pointers in C

Pointers are variables that store memory addresses. They are a powerful feature of C, allowing you to directly manipulate memory, work with arrays, and pass data efficiently.

Declaring Pointers

Use the * operator to declare a pointer. 


int x = 10;
int *ptr = &x;  // ptr stores the address of x

printf("Value of x: %d\n", x);
printf("Address of x: %p\n", ptr);

Dereferencing Pointers

Use the * operator to access the value stored at the memory address. 


int x = 10;
int *ptr = &x;

printf("Value at address %p: %d\n", ptr, *ptr);

Pointer Arithmetic

Pointers can be incremented or decremented to navigate through memory. This is particularly useful for arrays. 


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

for (int i = 0; i < 3; i++) {
    printf("Value at index %d: %d\n", i, *(ptr + i));
}

Pointers to Pointers

A pointer can also point to another pointer, creating a chain of pointers. 


int x = 10;
int *ptr = &x;
int **ptr2 = &ptr;

printf("Value of x: %d\n", **ptr2);

Pointers and Arrays

Arrays and pointers are closely related. The name of an array is essentially a pointer to its first element. 


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

printf("First element: %d\n", *ptr);
printf("Second element: %d\n", *(ptr + 1));

Pointers and Functions

Pointers can be passed to functions to modify variables outside the function's scope. 


#include <stdio.h>

void increment(int *ptr) {
    (*ptr)++;
}

int main() {
    int x = 10;
    increment(&x);
    printf("Value of x after increment: %d\n", x);
    return 0;
}

Pointers to Functions

You can also create pointers to functions, allowing you to pass functions as arguments or store them in arrays. 


#include <stdio.h>

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

int subtract(int a, int b) {
    return a - b;
}

int main() {
    int (*operation)(int, int); // Function pointer declaration

    operation = add; // Point to the add function
    printf("Sum: %d\n", operation(5, 3));

    operation = subtract; // Point to the subtract function
    printf("Difference: %d\n", operation(5, 3));

    return 0;
}

Dynamic Memory Allocation with Pointers

Pointers are essential for dynamic memory allocation using functions like malloc, calloc, and free. 


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

int main() {
    int *arr = (int *)malloc(5 * sizeof(int));  // Allocate memory for 5 integers

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

    for (int i = 0; i < 5; i++) {
        arr[i] = i + 1;
    }

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

    free(arr);  // Free the allocated memory
    return 0;
}

Common Pitfalls with Pointers

Be cautious of common mistakes when working with pointers:

Next: Dynamic Memory Allocation