Memory and Pointers

Articles covering pointers, references, dynamic memory management, and addressing in C++.

Memory and Pointers

The low-level power of C++: addressing, pointers and references; stack vs. heap; and dynamic memory management. Explore the risks of new/delete, safe patterns, and techniques to prevent memory leaks.

Goal: Apply addressing and dynamic memory correctly to write safe, bug-free C++ code.

TL;DR

Pointers & references: int* p, int& r, nullptr.
Dynamic memory: new/delete, new[]/delete[].
Arrays & pointer arithmetic: *(p + i).
Habits/tools: RAII; stepping stone to std::unique_ptr.

Addresses and Memory Basics

25 June 2026 • Memory and Pointers

How memory addresses work: bytes, layout, and how pointers reference locations.

C++ Memory

Read →

References vs Pointers

25 June 2026 • Memory and Pointers

Key differences: nullability, rebinding, indirection costs, and memory semantics.

C++ Pointer

Read →

Passing Parameters to Functions via Pointers

25 June 2026 • Memory and Pointers

Call by pointer: modifying values, simulating out params, and performance trade-offs.

C++ Functions Pointer

Read →

Relationship Between Arrays and Pointers

25 June 2026 • Memory and Pointers

Array-to-pointer decay, contiguous layout, and safe traversal via pointer arithmetic.

Arrays C++ Pointer

Read →

Dynamic Memory Management: new and delete

25 June 2026 • Memory and Pointers

Heap allocations, using new/delete safely, and practices that lead into RAII.

C++ C++ Memory Management new Operator

Read →

Memory Leaks and Analysis with valgrind

25 June 2026 • Memory and Pointers

Finding leaks with valgrind, interpreting reports, and common allocation pitfalls.

C++ Memory Leaks

Read →

Multidimensional Arrays and Pointer Usage

25 June 2026 • Memory and Pointers

2D/3D arrays, row-major layout, and indexing math with pointers in practice.

Arrays C++ Pointer

Read →

Introduction to Smart Pointers

25 June 2026 • Memory and Pointers

Getting started with unique_ptr, shared_ptr, and weak_ptr for safer lifetimes.

C++ Smart Pointers

Read →

In C++, choosing meaningful variable names makes the code easier to read and understand without needing extra comments.


// unclear
int x;
int y;

// clearer
int totalCount;
int maxRetries;

In C++, using auto improves readability when the type is obvious or very long. It helps focus on what the code does instead of how the type is written.


std::map<int, std::string> users;

// long and noisy
std::map<int, std::string>::iterator it = users.begin();

// clearer
auto it = users.begin();

In C++, defining variables inside a loop limits their scope and makes the code easier to understand and maintain.


// defined outside the loop
int value;
for (int i = 0; i < 5; i++)
{
    value = i * 2;
    std::cout << value << std::endl;
}

// better: define inside the loop
for (int i = 0; i < 5; i++)
{
    int value = i * 2;
    std::cout << value << std::endl;
}

In C++, pass large objects using const references to avoid unnecessary copies and improve performance.


void print(const std::vector<int>& values)
{
    for (int v : values)
    {
        std::cout << v << std::endl;
    }
}

In C++, avoiding unnecessary else blocks can make the code easier to read by reducing nesting and keeping the main logic clear.


bool isValid = false;

// harder to read
if (isValid)
{
    std::cout << "Valid";
}
else
{
    return;
}

// clearer
if (!isValid)
{
    return;
}

std::cout << "Valid";