C++ Pointers & References – Complete Guide with Function, Class & Lambda Examples

Pointers and references are foundational to advanced C++ programming. They provide direct access to memory, enable efficient data manipulation, and are central to dynamic memory, object-oriented design, and system-level programming.

Introduction – Why Master Pointers & References in C++?

C++ offers low-level memory control via pointers and flexible reference handling through references. Understanding these helps in optimizing performance, implementing data structures, and mastering concepts like polymorphism and callbacks.

In this guide, you’ll learn:

• The basics of pointers and pointer arithmetic
• How to use pointers with functions and classes
• The role of the this pointer
• Differences between pointers and references with examples

Topics Covered

C++ Pointers – Basics, Arithmetic, Modify

A pointer holds the address of another variable. You can perform arithmetic operations and dereference it to access or modify the original value.

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    int* ptr = &a;
    *ptr = 20;

    cout << "Value of a: " << a << endl; // Output: 20
    cout << "Pointer Address: " << ptr << endl;
    cout << "Dereferenced Value: " << *ptr << endl;
    return 0;
}

Explanation:

• int* ptr declares a pointer to an integer.
• &a gets the address of a.
• *ptr = 20 changes the value of a through the pointer.

C++ Pointer to Functions

Function pointers allow functions to be passed or invoked indirectly.

#include <iostream>
using namespace std;

int add(int x, int y) {
    return x + y;
}

int main() {
    int (*funcPtr)(int, int) = add;
    cout << "Sum: " << funcPtr(3, 4); // Output: 7
    return 0;
}

Use Case:

• Useful in callbacks, passing behavior to functions, and event handling.

C++ Pointer to Classes

Pointers to class objects are essential for dynamic memory and polymorphism.

#include <iostream>
using namespace std;

class MyClass {
public:
    void display() {
        cout << "Hello from class!" << endl;
    }
};

int main() {
    MyClass* obj = new MyClass();
    obj->display();  // Output: Hello from class!
    delete obj;
    return 0;
}

Key Points:

• Use -> to access class members via pointer.
• Always delete dynamically allocated memory to avoid leaks.

C++ this Pointer

this is an implicit pointer inside all non-static member functions, pointing to the current object.

#include <iostream>
using namespace std;

class MyClass {
    int value;
public:
    void setValue(int value) {
        this->value = value;
    }
    void show() {
        cout << "Value: " << value << endl;
    }
};

int main() {
    MyClass obj;
    obj.setValue(100);
    obj.show();  // Output: Value: 100
    return 0;
}

When to Use:

• To resolve variable shadowing
• To return the object itself in method chaining

C++ References – Pointer vs Reference

References are aliases for variables and behave differently from pointers.

#include <iostream>
using namespace std;

int main() {
    int a = 5;
    int& ref = a;

    ref = 10;
    cout << "a: " << a << endl; // Output: 10

    return 0;
}

Pointer vs Reference Comparison:

Summary – Recap & Next Steps

Pointers and references empower C++ developers with fine control over memory and behavior. From modifying values through memory addresses to crafting efficient object-oriented systems — mastering these concepts is essential.

Key Takeaways:

• Pointers store memory addresses and support arithmetic operations.
• Function pointers enable indirect function calls.
• Class pointers facilitate polymorphism and dynamic memory.
• this pointer gives access to the current object inside class methods.
• References are safer, simpler aliases but less flexible than pointers.

Real-World Relevance:

• Used in data structures (linked lists, trees), memory management, callback systems, and low-level systems programming.

Frequently Asked Questions (FAQs)

Can pointers in C++ be null?

Yes, pointers can be null and should be checked before dereferencing to avoid segmentation faults.

Can references be reassigned to another variable?

No. Once initialized, a reference cannot point to another variable.

What is the main benefit of using references?

Simplicity and safety — references can’t be null and don’t need dereferencing syntax.

When should I use pointers instead of references?

Use pointers when you need nullability, dynamic memory management, or reassignment of target addresses.

What is the difference between *ptr and &ref?

*ptr dereferences a pointer; &ref in declaration defines a reference. In expressions, & gets an address.