Cpp Programming Pointers And Pointer Arithmetic Complete Guide

Introduction to Pointers in C++

A pointer in C++ is a variable that stores the memory address of another variable as its value. Pointers have many uses, including the manipulation of arrays and implementation of data structures like linked lists.

Declaring and Initializing Pointers

To declare a pointer, you need to specify the type of the variable that the pointer will point to, followed by an asterisk (*) and the name of the pointer.

Example:

#include <iostream>

int main() {
    int var = 3;          // Variable of type int
    int *ptr;             // Pointer to int

    ptr = &var;           // Store the address of var in ptr

    std::cout << "Value of var: " << var << std::endl;
    std::cout << "Address of var: " << &var << std::endl;
    std::cout << "Address stored in ptr: " << ptr << std::endl;
    std::cout << "Value pointed to by ptr: " << *ptr << std::endl;

    return 0;
}

Output:

Value of var: 3
Address of var: 0x7ffee6b7d9ac      // This will be different on your machine
Address stored in ptr: 0x7ffee6b7d9ac // This will be the same as the address of var
Value pointed to by ptr: 3

Here, int *ptr declares a pointer named ptr that can point to an integer. ptr = &var stores the address of var in ptr. *ptr is used to dereference the pointer and access the value stored at the address it points to.

Pointer Arithmetic

Pointer arithmetic involves using arithmetic operators like +, -, ++, --, and += on pointers. However, these operations are only allowed on pointers to arrays.

Important Notes:

• Adding 1 to a pointer increments it by the size of the type it points to, not just 1 byte.
• Subtracting 1 from a pointer decrements it by the size of the type it points to.

Example:

#include <iostream>

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int *ptr = arr;         // Point to the first element of arr

    std::cout << "ptr points to value: " << *ptr << std::endl;

    ptr = ptr + 1;          // Move to the next element
    std::cout << "ptr points to value: " << *ptr << std::endl;

    ptr += 2;               // Move to the third after next element
    std::cout << "ptr points to value: " << *ptr << std::endl;

    ptr = ptr - 1;          // Move back to the previous element
    std::cout << "ptr points to value: " << *ptr << std::endl;

    ptr--;                  // Decrement to the previous element
    std::cout << "ptr points to value: " << *ptr << std::endl;

    return 0;
}

Output:

ptr points to value: 10
ptr points to value: 20
ptr points to value: 50
ptr points to value: 40
ptr points to value: 30

In this example, ptr is initially pointing to the first element of the array arr. We use ptr + 1, ptr += 2, ptr - 1, and ptr-- to navigate through the array and access different elements by adjusting the pointer.

Pointer Addition

Adding an integer to a pointer moves the pointer forward by that many elements in the array.

Example:

#include <iostream>

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int *ptr = arr;

    std::cout << "First element: " << *ptr << std::endl;     // Access first element
    std::cout << "Second element: " << *(ptr + 1) << std::endl; // Access second element
    std::cout << "Third element: " << *(ptr + 2) << std::endl;   // Access third element

    return 0;
}

Output:

First element: 10
Second element: 20
Third element: 30

Pointer Difference

Subtracting one pointer from another gives the number of elements between them in the array.

Example:

#include <iostream>

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int *ptr1 = arr;
    int *ptr2 = arr + 3;

    int diff = ptr2 - ptr1; // Difference in array indices

    std::cout << "Difference: " << diff << std::endl; // Output: 3

    return 0;
}

Output:

Difference: 3

NULL Pointers

A NULL pointer is a pointer that does not point to any particular memory location and has a value of 0.

Example:

#include <iostream>

int main() {
    int *ptr = NULL;
    int var = 5;

    std::cout << "Value of ptr before assignment: " << ptr << std::endl;

    ptr = &var;
    std::cout << "Value of ptr after assignment: " << ptr << std::endl;

    if (ptr != NULL) {
        std::cout << "ptr points to value: " << *ptr << std::endl;
    } else {
        std::cout << "ptr is NULL" << std::endl;
    }

    return 0;
}

Output:

Value of ptr before assignment: 0x0
Value of ptr after assignment: 0x7ffee6b7d9ac
ptr points to value: 5

Pointers to Arrays

Pointers can also be used to point to entire arrays. However, the pointer will point to the first element of the array.

Example:

#include <iostream>

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int *ptr = arr;   // Points to the first element of arr

    std::cout << "Address of first element: " << &arr[0] << std::endl;
    std::cout << "Address stored in ptr: " << ptr << std::endl;

    for (int i = 0; i < 5; i++) {
        std::cout << "Element at index " << i << ": " << *(ptr + i) << std::endl;
    }

    return 0;
}

Output:

Address of first element: 0x7ffee6b7d9ac
Address stored in ptr: 0x7ffee6b7d9ac
Element at index 0: 10
Element at index 1: 20
Element at index 2: 30
Element at index 3: 40
Element at index 4: 50

Pointers in Functions

Pointers can be used to pass arguments to functions by reference, allowing the function to modify the original variables.

Example:

#include <iostream>

// Function to swap two values using pointers
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 5, y = 10;

    std::cout << "Before swap: x = " << x << ", y = " << y << std::endl;

    swap(&x, &y);

    std::cout << "After swap: x = " << x << ", y = " << y << std::endl;

    return 0;
}

Output:

Before swap: x = 5, y = 10
After swap: x = 10, y = 5

In the swap function, the addresses of x and y are passed. The values pointed to by these addresses are then swapped.

Conclusion

Pointers are a powerful feature in C++ that allow you to manipulate memory addresses directly. This includes working with dynamic memory allocation, implementing complex data structures, and optimizing performance. However, they require careful handling to avoid common pitfalls like dereferencing NULL pointers or causing memory leaks.