Understanding C++ Pointers: The Power Behind the Address

Why Raw Pointers Still Matter

If you truly want to understand what's going on under the hood, you
need to understand raw pointers.

If you are a C++ developer, you've probably been encouraged to use smart
pointers like std::unique_ptr or std::shared_ptr. These are powerful
abstractions and, quite frankly, much safer to use in most cases.
However, they are still built on top of raw pointers.

If you truly want to understand what's going on under the hood, you need
to understand raw pointers. You may never need to use them directly, but
learning them gives you a solid foundation and a clearer understanding
of what's really happening.

Back when I was learning to code, raw pointers were the only option
available to us. To use them effectively, you had to become disciplined
about memory management. You had to think carefully about how and when
memory was allocated and destroyed on the heap. If you didn't get this
right, that's when you ended up with memory leaks.

Knowing how to use pointers—and how memory is manipulated—isn't
just about syntax. It's about understanding the machine.

So that brings us to the question: what is a pointer?

Simply put, a pointer is just another variable, like an int or a
float. However, this kind of variable is special because of what it
stores. Instead of holding a direct value, it stores the address of
another variable in memory. When a pointer holds the address of a
specific location, it is said to be "pointing" to that location. Using
special symbols, we can access the data stored there.

Let's take a closer look at this.

int x = 10;
int* ptr = &x;

Here's what's happening:

• x is an integer variable that holds the value 10
• &x means "the address of x"
• ptr is a pointer variable used to store the address of x
• int* placed in front of ptr declares it as a pointer to an integer

Depending on the context, the * symbol can mean two different things.
In a declaration, like above, it indicates that a variable is a pointer.
In other contexts, it is used to dereference the pointer—that is, to
access the value stored at the memory address it points to.

In other words, it allows us to access x, like so:

std::cout << *ptr;

The line above prints the value 10. As you can see, by using the
pointer, we accessed and displayed the value stored in x.

---

What Are Pointers Used For

Pointers are used when you need direct control over memory or when
working with structures that rely on relationships between objects.

1. Dynamic Memory Allocation

int* p = new int(5);

This allocates memory similar to the earlier example, but with one
important difference. The keyword new allocates memory on the heap
(delete deallocates it). In this case, it allocates enough space to
hold an integer, places the value 5 into that memory, and assigns the
address to the pointer p.

After this statement executes, you have an integer stored on the heap
with the value 5, and p points to it.

Note that p is a pointer to an integer. This is necessary because it
must store the address of a memory location that holds an integer.

2. Working with Data Structures

Complex structures like lists, trees, and graphs all rely on pointers to
connect their nodes.

struct Node {
    int data;
    Node* next;
};

This segment of code defines what's known as a self-referential
structure. The pointer inside it—called next—can hold the memory
address of another Node. In other words, each node can point to
another node of the same type.

Without pointers like this, data structures such as linked lists and
binary search trees could not exist.

3. Interfacing with Low-Level Systems

Operating systems, embedded systems, and performance-critical
applications often require direct memory access and control. Pointers
provide that level of control.

A good example is game development, where performance and memory
efficiency are critical.

---

How Pointers Work (The Basics)

When you declare:

int x = 10;

The system stores the integer value 10 at some location in memory. For
the sake of illustration, let's say the address where this value is
stored is 0x1000.

Now, when you write:

int* ptr = &x;

This statement is saying: take the memory address of x and store it in
ptr. In other words, make ptr point to x. At this point, ptr
contains the value 0x1000.

When you dereference ptr using the * operator, you are accessing the
value stored at the memory address that ptr holds—in this case, the
value inside x.

*ptr = 20;

This statement does not change the pointer itself. It changes the value
at the memory location the pointer is referring to. In this example, it
replaces the 10 stored in x with 20.

Key distinction:

• ptr by itself represents the address (for example, 0x1000)
• *ptr represents the value stored at that address (the same value stored in x)

That distinction—between the address and the value at the
address—is the key to understanding how pointers work.

---

A Final Thought

Even though it may sometimes seem that way, there's nothing magical
about pointers. They are simply variables that can do very powerful
things. Keeping that in mind is half the battle.

That said, there are important things you need to pay close attention
to. You must be disciplined when working with raw pointers. Mistakes,
carelessness, or poor memory management can lead to undefined behavior.
There's a real sense of responsibility that comes with using these
variables—but that responsibility is also what makes them so powerful.

Understanding raw pointers means understanding how C++ really works.

And once you understand that, everything else in the language starts to
make more sense.

---

See Pointers in Practice

If you'd like to see pointers used in a real project, I use them
throughout my Binary Search Tree implementation. The repository includes
the full C++ source code, along with supporting documentation and an API
reference that walks through the design and behavior of the structure.

GitHub repository:

https://github.com/arto-b/BST_Demo