C++ Developer -

Pointers store memory addresses and allow direct access to data in memory. They are a fundamental C++ feature that gives you low-level control over how data is stored and manipulated. Pointers support arithmetic, can be null, and can be reassigned to point to different objects. They are the backbone of dynamic memory allocation, data structures like linked lists, and array processing. This lesson covers declaring pointers, dereferencing, null checks, pointer arithmetic, and using pointers as parameters. Mastering pointers is essential for understanding how C++ manages memory at a granular level.

#include <iostream>
using namespace std;

int main() {
    int x = 42;
    int* ptr = &x;
    cout << *ptr;
    return 0;
}

• int* ptr = &x declares a pointer and stores the address of x.
• The & operator returns the memory address of a variable.
• The * operator dereferences the pointer to access the value at that address.
• cout << *ptr prints the value stored at the address held by ptr.

#include <iostream>
using namespace std;

int main() {
    int x = 10;
    int* ptr = &x;
    *ptr = 77;
    cout << x;
    return 0;
}

• You can change the original variable by assigning through the pointer.
• *ptr = 77 writes 77 into the memory location that ptr points to.
• This modifies x directly because ptr holds x address.
• Pointers give you indirect write access to any variable in scope.

#include <iostream>
using namespace std;

int main() {
    int* ptr = nullptr;
    if (ptr == nullptr) {
        cout << "null";
    } else {
        cout << *ptr;
    }
    return 0;
}

• A nullptr pointer points to nothing and should not be dereferenced.
• Always check for nullptr before using a pointer to avoid crashes.
• The condition ptr == nullptr checks whether the pointer is safe to use.
• Modern C++ prefers nullptr over the older NULL macro.

#include <iostream>
using namespace std;

int main() {
    int arr[] = {10, 20, 30};
    int* ptr = arr;
    cout << *ptr << " ";
    ptr++;
    cout << *ptr;
    return 0;
}

• When a pointer points to an array, ptr++ moves to the next element.
• Pointer arithmetic advances by the size of the pointed-to type automatically.
• The array name arr decays to a pointer to its first element.
• You can iterate through an array using pointer arithmetic instead of indices.

#include <iostream>
using namespace std;

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

int main() {
    int x = 5;
    increment(&x);
    cout << x;
    return 0;
}

• Passing a pointer to a function lets the function modify the original variable.
• The caller passes the address with &x, and the function receives it as int* p.
• Inside the function, (*p)++ increments the value at the pointed-to address.
• Parentheses are necessary because *p++ would increment the pointer, not the value.

#include <iostream>
using namespace std;

int main() {
    int x = 42;
    int* ptr = &x;
    int** pptr = &ptr;
    cout << **pptr;
    return 0;
}

• A pointer to a pointer stores the address of another pointer variable.
• Declare it with two asterisks: int** pptr = &ptr.
• To reach the original value, use double dereference: **pptr.
• This is used in multi-dimensional dynamic arrays and modifying pointer arguments.