Pointers in C Programming

Introduction

Pointers are variables that store memory addresses of other variables. They are fundamental in C++ programming, enabling dynamic memory allocation and efficient manipulation of data structures.

The & and * Operator

The & operator returns the address of a variable, while the * operator is used to declare a pointer and to access the value stored at the memory address pointed to by the pointer.

Declaration of Pointer

Pointers are declared using the syntax: data-type *pointer-variable;. For example: int *ptr; declares a pointer variable ptr pointing to an integer data type.

int main() {
    int var = 10;
    int *ptr = &var; // Declaration and initialization of pointer
    return 0;
}
    

Chain of Pointers

A chain of pointers refers to a sequence of pointers where each pointer points to the memory address of another pointer or variable. This concept is often used in complex data structures and dynamic memory allocation.

int main() {
    int var = 10;
    int *ptr1 = &var;
    int **ptr2 = &ptr1; // Pointer to pointer
    return 0;
}
    

Pointer Arithmetic

Pointer arithmetic involves performing arithmetic operations on pointers, such as addition and subtraction. These operations are used to navigate through arrays and dynamic memory blocks.

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int *ptr = arr; // Pointer to array
    ptr++; // Increment pointer
    return 0;
}
    

Pointers and Arrays

Pointers and arrays are closely related in C++. Arrays can be accessed using pointers, and pointer arithmetic is often used to traverse array elements efficiently.

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int *ptr = arr; // Pointer to array
    for (int i = 0; i < 5; i++) {
        cout << *(ptr + i) << " "; // Accessing array elements using pointer
    }
    return 0;
}
    

Pointers and Character Strings

Character strings in C++ are represented as arrays of characters. Pointers are commonly used to manipulate and traverse character strings efficiently.

int main() {
    char str[] = "Hello";
    char *ptr = str; // Pointer to string
    while (*ptr != '\0') {
        cout << *ptr;
        ptr++; // Move to next character
    }
    return 0;
}
    

Array of Pointers

An array of pointers is an array where each element is a pointer to another variable or object. This concept is often used in applications involving dynamic memory allocation and multi-dimensional arrays.

int main() {
    int var1 = 10, var2 = 20, var3 = 30;
    int *ptrArr[3] = {&var1, &var2, &var3}; // Array of pointers
    for (int i = 0; i < 3; i++) {
        cout << *ptrArr[i] << " "; // Accessing values using array of pointers
    }
    return 0;
}
    

Pointers as Function Arguments

Pointers can be passed as arguments to functions, enabling functions to modify variables outside their scope and to operate on large data structures efficiently.

void modifyValue(int *ptr) {
    *ptr = 20; // Modify value using pointer
}

int main() {
    int var = 10;
    modifyValue(&var); // Pass pointer to function
    cout << var; // Output: 20
    return 0;
}
    

Function Returning Pointers

Functions in C++ can return pointers, allowing them to dynamically allocate memory and return the address of the allocated memory block. This feature is commonly used in applications involving dynamic data structures.

int* createArray(int size) {
    int *ptr = new int[size]; // Dynamically allocate memory
    return ptr;
}

int main() {
    int *arr = createArray(5); // Call function to create array
    // Use array
    delete[] arr; // Free dynamically allocated memory
    return 0;
}
    

Pointers and Structures

Pointers can be used to access members of structures dynamically. This allows for efficient manipulation of complex data structures and objects.

struct Student {
    int id;
    string name;
};

int main() {
    Student *ptr = new Student; // Create pointer to structure
    ptr->id = 1; // Access structure members using pointer
    ptr->name = "John";
    delete ptr; // Free dynamically allocated memory
    return 0;
}
    

Dynamic Memory Allocation

Dynamic memory allocation refers to the process of allocating memory at runtime using the new operator. Pointers are used to manage dynamically allocated memory blocks, enabling flexible memory management in C++ programs.

int main() {
    int *ptr = new int; // Allocate memory dynamically
    *ptr = 10; // Store value in dynamically allocated memory
    cout << *ptr; // Output: 10
    delete ptr; // Free dynamically allocated memory
    return 0;
}