← Back to all posts

07 C++ Notes

Pointers, Part 1: Declaration and Memory

C++ Notes

Declaration and Use

Introduction

When a variable is created, the system gives it some memory with a specific address.
This is true for both primitive types (int, char) and non-primitive types (objects, arrays).
A pointer is a special variable that stores the address of another variable, not the data itself.

Declaration

Each datatype has its own pointer type. The pointer type is the datatype name followed by *: int* px, double* py, long double* pz.
Storing an address in an incompatible pointer type gives a compiler error.
The location of the star doesn't matter: int* p, int *p, int * p are all the same.
To get the address of a variable, prefix it with &: int* p{&num}; stores the address of num in p (braces preferred).
A declared but uninitialized pointer contains a junk address. This must never be used.
Empty braces declare a null pointer, one that points nowhere: int* p{} is the same as int* p{nullptr}.
All pointer types have the same size, because they all just store addresses: sizeof(int*) == sizeof(double*) == sizeof(int**). 4 bytes on a 32-bit system, 8 bytes on a 64-bit system.
Do not declare more than one pointer on a single line. The * binds to the variable, not the base type: int* p{}, q{}; declares one pointer and one plain int, which is very misleading to read.

Using a Pointer

Using the pointer directly works with the address: p prints the stored address, p = &x assigns the address of x to p.
Using the pointer with *, dereferencing, works with the data at that address: *p prints the value stored at that address, *p = 23 writes 23 into the memory at that address.

Pointers to Pointers

A pointer can point to another pointer. Each level adds one more * to the type: int* is a pointer to int, int** is a pointer to int*, int*** is a pointer to int**.
Pointers store addresses only in the order allowed by C++: int*** stores the address of an int**, which stores the address of an int*, which stores the address of an int.
Anything against this chain gives a compilation error.

Trick: "star kills p." The rule is that stars must never outnumber the p-levels. Each star strips one level of indirection. Given int x{23}, int* p{&x}, int** pp{&p}, int*** ppp{&pp}: *p behaves like x (gives value 23), *pp behaves like p (gives address of x), *ppp behaves like pp (gives address of p), and ***ppp behaves like x (gives value 23). "Behaves like" means both the type and the data it contains are equivalent.

Const Pointers

const binds to whatever is on its left. If nothing is on the left, it binds to the right. This one rule decides what exactly ends up const.

Declaration	Modify value (`*p = 5`)?	Rebind pointer (`p = &y`)?	Use when
`const int* p` (same as `int const* p`)	No	Yes	You want to protect the data through this pointer, but still allow it to point elsewhere later.
`int* const p`	Yes	No	The pointer's identity must stay fixed, but mutating the data through it is fine.
`const int* const p`	No	No	Both the identity and the data must stay fixed for the rest of the pointer's life.

The object itself never becomes const, only your view through that particular pointer does. Another pointer with a non-const view can still modify the exact same data. For example: int* p2{new int{10}}; and const int* const q{p2};, then *p2 = 20; is allowed, but *q = 20; is not, even though p2 and q point at the same memory.

Code Example: main.cpp

C++

#include <iostream>

int main() {
    int x{23};
    std::cout << "x        = " << x  << '\n'; // prints: 23
    std::cout << "&x       = " << &x << '\n'; // prints: address of x

    int* p{&x};
    std::cout << "p        = " << p   << '\n'; // prints: address of x (same as &x)
    std::cout << "*p       = " << *p  << '\n'; // prints: 23

    *p = 50; // write through pointer into x
    std::cout << "x after  = " << x  << '\n'; // prints: 50 (x was changed via pointer)

    int** pp{&p};
    std::cout << "pp       = " << pp   << '\n'; // prints: address of p
    std::cout << "*pp      = " << *pp  << '\n'; // prints: address of x (same as p)
    std::cout << "**pp     = " << **pp << '\n'; // prints: 50

    int*** ppp{&pp};
    std::cout << "ppp      = " << ppp    << '\n'; // prints: address of pp
    std::cout << "*ppp     = " << *ppp   << '\n'; // prints: address of p (same as pp)
    std::cout << "**ppp    = " << **ppp  << '\n'; // prints: address of x (same as p)
    std::cout << "***ppp   = " << ***ppp << '\n'; // prints: 50

    int* q{};             // null pointer (safe, points nowhere)
    int* nullPtr{nullptr}; // same as above
    std::cout << "q        = " << q       << '\n'; // prints: 0
    std::cout << "nullPtr  = " << nullPtr << '\n'; // prints: 0

    std::cout << "sizeof(int*)    = " << sizeof(int*)    << '\n'; // prints: 8 (64-bit)
    std::cout << "sizeof(int**)   = " << sizeof(int**)   << '\n'; // prints: 8
    std::cout << "sizeof(double*) = " << sizeof(double*) << '\n'; // prints: 8 (all pointers same size)

    return 0;
}

Pointer to Char

Char Pointer Basics

A char pointer works like any other pointer: char* p creates a pointer to char, p = &x stores the address of a char variable, p gives the address, and *p gives the char data at that address.

String Literal and Char Pointer

A string literal like "Hello, World!" is an array of const char stored in read-only memory.
That array decays to a pointer to its first character, so it can be stored in a pointer directly.
Some compilers refuse char* message{"Hello, World!"};, because the literal is actually const char[], and assigning it to a non-const pointer is unsafe.
The correct, portable form is const char* message{"Hello, World!"};. This pointer cannot be used to modify the data, but message[index] still works fine for reading any character.

cout treats a char* specially. When it points to a null-terminated character sequence, it prints the entire string rather than the address. For any other pointer type, it prints the address as usual. If you actually want the address of a char pointer, cast it: (void*)p.

Const Pointer vs Char Array

Both of these print as text through cout, since both refer to null-terminated character sequences: const char* message{"Hello, World!"} and char message[]{"Hello, World!"}. The difference is what you can actually do with them.

const char*	char[]
Data cannot be modified through the pointer, since the underlying literal lives in read-only memory.	Data can be modified freely by index, since it's a real, writable array on the stack.

For a modifiable char string, always use an actual char array with [].

Code Example: main.cpp

C++

#include <iostream>

int main() {
    char x{'A'};
    char* p{&x};
    std::cout << "p (address): " << (void*)p << '\n'; // cast to void* to print address (otherwise cout prints string)
    std::cout << "*p (data):   " << *p       << "\n\n"; // prints: A

    // string literal: stored in read-only memory, const char* is required
    const char* message{"Hello, World!"};
    std::cout << "message:    " << message    << '\n';  // prints: Hello, World!
    std::cout << "*message:   " << *message   << '\n';  // prints: H (first char)
    std::cout << "message[1]: " << message[1] << "\n\n"; // prints: e

    // char array: data is modifiable
    char message2[]{"Hello, World!"};
    std::cout << "message2:    " << message2    << '\n'; // prints: Hello, World!
    std::cout << "*message2:   " << *message2   << '\n'; // prints: H
    std::cout << "message2[1]: " << message2[1] << '\n'; // prints: e
    message2[0] = 'h';
    message2[7] = 'w';
    std::cout << "message2 (after changes): " << message2 << '\n'; // prints: hello, world!

    return 0;
}

Program Memory Map

Why Virtual Memory Exists

Multiple programs run on the OS at the same time.
If all programs directly used real RAM, we'd run out of memory very quickly.
It's also impossible to load every program completely into RAM at once.
This problem gave birth to virtual memory, which gives each program the illusion that it's the only program running, and that it owns a very large, private memory space.

Process and Memory Map

A program file, the binary, on disk is not executed directly.
The OS loads it, adds required information, and turns it into a process.
Process = running program + memory map + execution state and other bookkeeping.
The memory map is the per-process representation of virtual memory, the model or view a process has of memory, like a city map handed to someone saying "this is your city."
A memory map consists of virtual addresses ranging from 0 to 2^N minus 1, where N is 32 or 64. Those addresses are divided into regions: text, data, heap, stack.
Each process gets its own memory map instance. It isn't real memory, it's a promise made by the OS.
All memory map instances follow the same layout defined by the OS and the executable format, which is exactly why Linux executables don't run on Windows and vice versa.
The entire program isn't loaded into real RAM at once, only the needed parts get loaded when required, the rest can stay on the hard disk, making efficient use of limited real RAM.

MMU: Address Translation

The MMU, Memory Management Unit, is a hardware component inside the CPU.
It translates virtual addresses used by a process into real physical RAM addresses.
Programs never access real RAM directly, they always work through virtual addresses.
The MMU and OS together map the memory maps of multiple processes onto real RAM, keep processes isolated from each other, and prevent one program from accessing another program's memory.

Memory Map Regions

Region	What Lives There
Text section	The binary machine code of the program. Read-only.
Data section	Global and static variables.
Stack	Local variables and function call frames. Managed automatically, with a fixed size decided at compile time.
Heap	Dynamic memory allocation. Controlled entirely by the programmer using `new` and `delete`. Larger and flexible.
System / kernel region	Protected memory used by the OS. Programs cannot access this directly.

For a C++ programmer, stack and heap are the two regions that actually matter day to day, they're the ones you're constantly making decisions about, which is exactly what the next section is about.

Dynamic Memory Allocation

Stack vs Heap

Stack Memory Heap Memory

Stack Memory	Heap Memory
Smaller, fixed, and automatic. Size decided at compile time, the compiler knows exactly how many bytes a function or scope needs. Runtime uses a stack pointer to track the top of the stack (LIFO-based). When a function or scope ends, the stack pointer moves back by the known number of bytes, releasing memory automatically. The developer isn't in full control of memory lifetime. Pointers are optional. Stack variables can be accessed directly by name.	Larger in size, flexible, and runtime-based. Size is decided during program execution, not at compile time. No fixed stack pointer exists to rewind heap memory automatically. The developer is in full control of memory lifetime. Pointers are mandatory to access heap memory, there are no names for heap objects. `new` and `delete` operators are used.

Smaller, fixed, and automatic.

Size decided at compile time, the compiler knows exactly how many bytes a function or scope needs.

Runtime uses a stack pointer to track the top of the stack (LIFO-based).

When a function or scope ends, the stack pointer moves back by the known number of bytes, releasing memory automatically.

The developer isn't in full control of memory lifetime.

Pointers are optional. Stack variables can be accessed directly by name.

Larger in size, flexible, and runtime-based.

Size is decided during program execution, not at compile time.

No fixed stack pointer exists to rewind heap memory automatically.

The developer is in full control of memory lifetime.

Pointers are mandatory to access heap memory, there are no names for heap objects.

new and delete operators are used.

How Dynamic Allocation Works

new creates a memory block on the heap, not a named variable.
The compiler doesn't know this memory at compile time, it's created at runtime.
The only way to access heap memory is through a pointer.
The pointer itself is a normal variable, usually stored on the stack.
When the pointer's scope ends, the pointer is destroyed, but the heap memory is not destroyed automatically.
The developer must explicitly free heap memory using delete. Failing to do so causes a memory leak.
After delete, always reset the pointer to nullptr to prevent a dangling pointer.

C++

int* p{};        // pointer on stack, initialized to nullptr
p = new int;    // heap memory for 1 int allocated; address assigned to p
*p = 34;        // write value into heap memory
std::cout << p;  // prints the address stored in p
std::cout << *p; // prints the value at that address (34)
delete p;        // destroys data and releases heap memory
p = nullptr;     // prevents dangling pointer

Heap Initialization Forms

C++

int* p{new int};      // heap int allocated, value uninitialized (garbage)
int* p{new int{}};    // heap int allocated, value-initialized to 0
int* p{new int(33)};  // heap int allocated, initialized to 33
int* p{new int{33}};  // heap int allocated, brace-initialized to 33 (preferred)

Memory Leaks

A memory leak occurs when dynamically allocated memory is no longer accessible.
It happens when a pointer is reassigned without deleting the old memory first.
It also occurs when a pointer goes out of scope without freeing the heap memory it held.
Leaked memory cannot be deleted or reused for the rest of the program's lifetime.
Always delete and reset a pointer before it dies, or before it points elsewhere.

Do not write into an uninitialized pointer (int* p;), the compiler won't warn you, and the junk address may belong to the OS or some other part of memory entirely. Don't write into a nullptr either. And don't call delete twice on the same pointer before assigning it to new memory, if two pointers point to the same memory, only one of them should be the owner that actually calls delete.

Code Example: main.cpp

C++

#include <iostream>

int main() {
    // stack variables (automatic, named, no manual cleanup needed)
    int x = 10;
    int y = 20;
    std::cout << "Stack variables:\n";
    std::cout << "x = " << x << "\n"; // prints: 10
    std::cout << "y = " << y << "\n"; // prints: 20

    // heap memory (dynamic, unnamed, must be managed manually)
    int* p{};      // pointer on stack, nullptr
    p = new int;  // heap block allocated (no variable name)
    *p = 34;       // write into heap memory
    std::cout << "\nHeap memory:\n";
    std::cout << "Address in p: " << p  << "\n"; // prints: some address
    std::cout << "Value at p:   " << *p << "\n"; // prints: 34
    delete p;     // free heap memory
    p = nullptr;  // reset to prevent dangling pointer

    // different initialization forms
    int* a = new int;      // uninitialized (garbage)
    int* b = new int{};    // value-initialized to 0
    int* c = new int(33);  // initialized to 33
    int* d = new int{33};  // brace-initialized to 33
    std::cout << "\nInitialization forms:\n";
    std::cout << "*a (garbage): " << *a << "\n"; // unpredictable
    std::cout << "*b {}:        " << *b << "\n"; // prints: 0
    std::cout << "*c (33):      " << *c << "\n"; // prints: 33
    std::cout << "*d {33}:      " << *d << "\n"; // prints: 33
    delete a; a = nullptr;
    delete b; b = nullptr;
    delete c; c = nullptr;
    delete d; d = nullptr;

    return 0;
}

Closing

That's how pointers work and where the memory they point at actually lives, from a single address all the way up to the OS deciding what stack and heap even mean. Next up, part 2: everything that goes wrong with pointers, and how to keep it from going wrong.