Pointers

Introduction

In the previous lesson, you learned about references, which provide another name for an existing object. C++ also allows programs to work with the memory address of an object.

int number = 100;

When this variable is created, the computer stores its value somewhere in memory. The exact address is chosen by the system and may be different each time the program runs.

Variable: number

Address          Value
0x1000 ────────► 100

Normally, we use the variable name to work with the value. Sometimes, however, a program needs to store and work with the address of an object itself.

What is a Pointer?

A pointer is a variable that stores the memory address of another object.

An ordinary variable stores a value directly, while a pointer stores an address that can identify another object.

int number = 100;
int *ptr = &number;

ptr
 │
 │ stores address of number
 ▼
number ─────► 100

Why Do We Need Pointers?

Pointers are an important part of C++ because they allow programs to represent optional objects, build dynamic structures, manage resources, interact with low-level systems, and work with dynamically allocated memory.

Real-World Analogy

Imagine a hotel. A guest named Rahul is staying in room 101. Instead of carrying Rahul himself, a note can simply contain his room number.

Pointer Note
┌─────────────┐
│ Room 101    │
└──────┬──────┘
       │
       ▼
┌─────────────┐
│ Room 101    │
│ Rahul       │
└─────────────┘

The room number tells you where Rahul can be found. Similarly, a pointer stores an address that identifies where an object can be accessed.

Variables and Memory

Every object used by a running program occupies storage. Consider the following integer variable.

int number = 100;

Conceptually, the program has a value stored at some memory address.

Variable Name: number

Memory Address       Stored Value
─────────────────────────────────
0x1000               100

Pointer Declaration & Address-of Operator

To declare a pointer, use the * symbol in the declaration.

data_type *pointer_name;

int *ptr;

This declares ptr as a pointer to int. It means ptr can store the address of a compatible int object.

To obtain the address of an object, use the address-of operator &.

int number = 100;

std::cout << &number;

The expression &number produces the address of number.

int number = 100;
int *ptr = &number;

Example 1: Displaying Memory Address

#include <iostream>

int main()
{
    int number = 100;

    std::cout << number << std::endl;
    std::cout << &number;

    return 0;
}

100
0x61ff08

Example 2: Creating a Pointer

The address of an object can be stored in a compatible pointer.

#include <iostream>

int main()
{
    int number = 100;
    int *ptr = &number;

    std::cout << ptr;

    return 0;
}

number
Address: 0x1000
┌─────────────┐
│    100      │
└─────────────┘
      ▲
      │
      │ points to
      │
ptr
Address: 0x2000
┌─────────────┐
│   0x1000    │
└─────────────┘

The Dereference Operator (*)

Once a pointer stores the address of an object, the dereference operator * can be used to access the object through that pointer.

*pointer_name

int number = 100;
int *ptr = &number;

std::cout << *ptr;

The expression *ptr means: access the object located at the address stored in ptr.

ptr contains 0x1000
        │
        ▼
Go to address 0x1000
        │
        ▼
Access value 100

Example 3: Dereferencing a Pointer

#include <iostream>

int main()
{
    int number = 100;
    int *ptr = &number;

    std::cout << *ptr;

    return 0;
}

100

Example 4: Modifying a Variable Using a Pointer

A valid non-const pointer can also be used to modify the object to which it points.

#include <iostream>

int main()
{
    int number = 100;
    int *ptr = &number;

    *ptr = 250;

    std::cout << number;

    return 0;
}

ptr ─────► number ─────► 100

ptr ─────► number ─────► 250

250

Program Execution Flow

The pointer workflow involves obtaining an address, storing it in a compatible pointer, and dereferencing the pointer only when it refers to a valid object.

Comparisons

Pointers become easier to understand when compared with ordinary variables and references.

Pointer vs Variable

Reference vs Pointer

int number = 100;
int &ref = number;

ref = 250;

int number = 100;
int *ptr = &number;

*ptr = 250;

Real-World Applications

int first = 10;
int second = 20;

int *ptr = &first;

ptr = &second;

Unlike a reference, a pointer can later store the address of another compatible object.

Advantages of Pointers

Common Beginner Mistakes

// ❌ Dangerous
int *ptr;
std::cout << *ptr;

// ✅ Safe initial state
int *ptr = nullptr;

int number = 100;

// ❌ Incorrect
// int *ptr = number;

// ✅ Correct
int *ptr = &number;

int *ptr = nullptr;

// ❌ Undefined behavior
// std::cout << *ptr;

int *ptr = nullptr;

if (ptr != nullptr)
{
    std::cout << *ptr;
}

Best Practices

int *ptr = nullptr;

if (ptr != nullptr)
{
    std::cout << *ptr;
}

int number = 100;
int *ptr = &number;

std::cout << *ptr;

Frequently Asked Questions

Key Takeaways

Summary

Pointers are one of the most important low-level features of C++. A pointer stores an address and can provide indirect access to another object.

The address-of operator & obtains the address of an object, while the dereference operator * accesses the object through a valid pointer.

Pointers can be used to read and modify objects, represent optional relationships with nullptr, build linked data structures, work with dynamic memory, and interact with system-level APIs.

Pointers also require careful handling. Uninitialized, null, and dangling pointers must never be dereferenced. Understanding pointer validity and object lifetime is essential for writing safe C++ programs.

With references and pointers understood, you are ready to begin object-oriented programming by learning how C++ classes combine data and behavior into reusable types.