What are and how to use Pointers in C++

A pointer is a variable that stores the memory address of another variable. This capability allows pointers to manipulate data in memory.

Instead of directly containing a data value, a pointer contains the address where that value is located. Therefore, they are one of the simplest ways to perform a reference.

Definition of a pointer

The basic syntax for defining a pointer is:

type *pointerName;

For example,

int *ptr;

Dereference operator

The dereference operator * is used to access the value of the variable that the pointer points to.

int var = 10;
int *ptr = &var;

std::cout << "Value of var: " << var << std::endl;
std::cout << "Value of var using pointer: " << *ptr << std::endl;

Assignment of addresses

To assign a memory address to a pointer, the address operator & is used.

int var = 10;
int *ptr = &var;

Pointers and arrays

Arrays and pointers are closely related in C++. The name of an array is itself a pointer to the first element of the array.

int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr;

std::cout << "First element of the array: " << *ptr << std::endl;
std::cout << "Second element of the array: " << *(ptr + 1) << std::endl;

Pointers and functions

Pointers can be used to pass large data structures to functions without the need to copy them, which is efficient in terms of memory and time.

#include <iostream>

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

int main() {
    int num = 10;
    increment(&num);
    std::cout << "Value of num after incrementing: " << num << std::endl;
    return 0;
}

Pointers and dynamic memory

In C++, memory can be managed dynamically using the new and delete operators.

Dynamic memory allocation

int *ptr = new int;
*ptr = 20;
std::cout << "Value stored in dynamic memory: " << *ptr << std::endl;
delete ptr;

Dynamic arrays

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

for (int i = 0; i < 5; ++i) {
    std::cout << "arr[" << i << "] = " << arr[i] << std::endl;
}

delete[] arr;

Pointers to pointers

A pointer to a pointer is a variable that contains the address of a pointer, allowing additional levels of indirection.

int var = 5;
int *ptr = &var;
int **pptr = &ptr;

std::cout << "Value of var: " << var << std::endl;
std::cout << "Value of var using ptr: " << *ptr << std::endl;
std::cout << "Value of var using pptr: " << **pptr << std::endl;

int *ptr = nullptr;

int *ptr = new int;
delete ptr;

int *ptr = nullptr;

Complete example

Let’s look at a somewhat broader example, where we would see dynamic management of a list of integers.

#include <iostream>

class IntegerList {
private:
    int *data;
    int capacity;
    int size;

public:
    IntegerList(int cap) : capacity(cap), size(0) {
        data = new int[capacity];
    }

    ~IntegerList() {
        delete[] data;
    }

    void add(int value) {
        if (size < capacity) {
            data[size++] = value;
        } else {
            std::cerr << "List capacity exceeded" << std::endl;
        }
    }

    void display() const {
        for (int i = 0; i < size; ++i) {
            std::cout << data[i] << " ";
        }
        std::cout << std::endl;
    }
};

int main() {
    IntegerList list(10);
    list.add(1);
    list.add(2);
    list.add(3);

    std::cout << "Elements in the list: ";
    list.display();

    return 0;
}