Dereferencing a Pointer in C and C++ Explained with Examples

By the end of this page, you will understand what a pointer stores, what dereferencing means, how the * operator is used to access the value at an address, and how this appears in real C and C++ programs. You will also learn common mistakes, how to read pointer syntax, and how to safely use dereferencing in beginner-friendly code.

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

Dereferencing a pointer means:

• going to the memory address stored in the pointer
• accessing or modifying the value that lives at that address

In C and C++, the dereference operator is *.

For example:

int x = 10;
int* p = &x;

• x stores the value 10
• &x means "the address of x"
• p stores that address
• *p means "the value stored at the address inside p"

So if p points to x, then *p refers to x.

That means this is true:

*p = 25;

After this line, x becomes 25.

Why this matters

Think of a pointer like a piece of paper with a house address written on it.

• The house is the actual variable in memory.
• The address on the paper is the pointer's value.
• Dereferencing means going to that house and seeing what is inside.

Example:

• x is a house containing 10
• p is a note that says where x lives
• *p means "go to that house and open the door"

If you write through *p, you are not changing the note. You are changing what is inside the house.

That is why:

*p = 99;

changes the original variable being pointed to.

Core syntax

int x = 10;
int* p = &x;   // p stores the address of x
int y = *p;    // dereference p to get the value at that address

Example 1: Reading a value through a pointer

#include <iostream>
using namespace std;

int main() {
    int x = 42;
    int* p = &x;

    cout << x << "\n";   // 42
    cout << p << "\n";   // memory address of x
    cout << *p << "\n";  // 42
}

Explanation

• x stores 42
• p stores the address of x
• *p follows that address and reads the value there

Example 2: Modifying a value through a pointer

Consider this small example:

#include <iostream>
using namespace std;

int main() {
    int x = 5;
    int* p = &x;
    int y = *p;
    *p = 12;

    cout << x << " " << y << "\n";
}

Step-by-step trace

1. int x = 5;

A normal integer variable named x is created.

• x contains 5

2. int* p = &x;

A pointer named p is created.

• &x gets the address of x
• p stores that address
• p now points to

Dereferencing appears in many real programs.

1. Updating values inside functions

In C, functions often use pointers when they need to modify caller-owned data.

void setZero(int* value) {
    *value = 0;
}

2. Working with arrays

Array names often behave like pointers to the first element.

int arr[3] = {10, 20, 30};
int* p = arr;

// *p is arr[0]
// *(p + 1) is arr[1]

Dereferencing is how pointer-based array access works.

3. Dynamic memory

When memory is allocated dynamically, you usually access it through a pointer.

int* p = new int(50);
cout << *p << "\n";
delete p;

4. Data structures

Linked lists, trees, graphs, and many low-level containers rely on pointers.

node->next

This is closely related to dereferencing. is shorthand for dereferencing a pointer to an object and accessing one of its members.

In real codebases, dereferencing is rarely taught in isolation. It usually appears as part of common programming patterns.

Guard clauses before dereferencing

Developers often check for nullptr or NULL before using a pointer.

void printValue(const int* p) {
    if (p == nullptr) {
        return;
    }

    cout << *p << "\n";
}

This avoids invalid memory access.

Output parameters in C-style APIs

Many C functions return results through pointer parameters.

void divide(int a, int b, int* result) {
    if (b == 0 || result == NULL) {
        return;
    }
    *result = a / b;
}

Iterating with pointers

Some performance-sensitive code uses pointers directly instead of indexes.

int arr[3] = {, , };
 (* p = arr; p < arr + ; ++p) {
    cout << *p << ;
}

1. Dereferencing an uninitialized pointer

Broken code:

int* p;
cout << *p << "\n";

Problem

p does not point to a valid location. Dereferencing it causes undefined behavior.

Fix

Always initialize pointers.

int x = 10;
int* p = &x;
cout << *p << "\n";

2. Dereferencing nullptr or NULL

Broken code:

int* p = nullptr;
cout << *p << "\n";

Problem

A null pointer points to no valid object.

Fix

Check before dereferencing.

if (p != nullptr) {
    cout << *p << "\n";
}

3. Confusing address-of and dereference

Broken code:

Related operators and ideas

Quick reference

Pointer declaration

int* p;

p is a pointer to int.

Store an address in a pointer

int x = 10;
int* p = &x;

Dereference a pointer

cout << *p;

Reads the value at the address stored in p.

Write through a pointer

*p = 20;

Changes the original value being pointed to.

Address-of vs dereference

&x   // address of x
*p   // value at pointer p

Pointer to struct/object member

p->member
(*p).member

These mean the same thing.

Safety rules

What does dereferencing mean in C or C++?

Dereferencing means accessing the value stored at the memory address held by a pointer. In code, this is usually done with *pointer.

What is the difference between p and *p?

p is the address stored in the pointer. *p is the value found at that address.

Why is & used when assigning a pointer?

& gets the address of a variable. A pointer stores addresses, so int* p = &x; gives p the location of x.

Can dereferencing change the original variable?

Yes. If a pointer points to a variable, assigning to *p changes that original variable.

Is dereferencing a null pointer allowed?

No. Dereferencing nullptr in C++ or NULL in C is invalid and causes undefined behavior.

Is p->member the same as (*p).member?

Related topics to learn next

• Pointers — Dereferencing only makes sense once you understand what a pointer stores.
• Address-of operator (&) — This is how you get the address that a pointer can store.
• References in C++ — References provide another way to access existing variables without explicit pointer syntax.
• Arrays and pointer arithmetic — Array access is deeply connected to pointers and dereferencing.
• Dynamic memory allocation — new, delete, malloc, and free all involve pointers.
• Structs and classes — Dereferencing is often used when accessing members through pointers.
• Null pointers — Important for writing safe pointer code.
• Pass-by-pointer vs pass-by-reference — Useful for understanding how functions modify outside values.