Week 7: Memory Management - Pointers & References

Chapter 7: Pointers, References, and Memory

Memory Addresses.

Every variable you declare in your C++ program resides at a specific location in the computer's memory. This location has a unique memory address, often represented as a hexadecimal number.

You can get the memory address of a variable using the address-of operator (`&`).

#include <iostream>

int main() {
    int score = 100;
    double price = 19.99;

    std::cout << "Address of score: " << &score << std::endl; // Prints the memory address (e.g., 0x7ffc1234abcd)
    std::cout << "Address of price: " << &price << std::endl; // Prints a different memory address

    return 0;
}

Understanding memory addresses is fundamental to understanding pointers.

Dynamic Memory Allocation (`new` and `delete`).

So far, variables we've declared have their memory managed automatically (on the stack or in the static/global area). C++ also allows you to allocate memory dynamically at runtime from a memory pool called the heap (or free store).

This is essential when you don't know the amount of memory needed until the program is running, or when you need an object to exist beyond the scope where it was created.

`new` Operator

The `new` operator allocates memory on the heap and returns a pointer to the beginning of that allocated block.

int* ptrInt = new int; // Allocate memory for one integer
*ptrInt = 55;      // Assign a value to the allocated memory

double* ptrDouble = new double(99.9); // Allocate and initialize

// Allocate an array dynamically
int size = 10;
int* ptrArray = new int[size]; // Allocate memory for an array of 10 integers
ptrArray[0] = 1; // Use it like a regular array

`delete` Operator

Memory allocated with `new` is not automatically managed. You are responsible for releasing it back to the system when it's no longer needed using the `delete` operator (for single objects) or `delete[]` (for arrays allocated with `new[]`).

Failure to `delete` dynamically allocated memory leads to memory leaks!

std::cout << *ptrInt << std::endl; // Use the allocated memory

delete ptrInt;     // Deallocate the single integer
ptrInt = nullptr; // Good practice to nullify pointer after delete

delete ptrDouble; // Deallocate the single double
ptrDouble = nullptr;

delete[] ptrArray; // Deallocate the dynamically allocated array (use delete[])
ptrArray = nullptr;

Managing dynamic memory carefully is critical in C++. Modern C++ often uses smart pointers (like `std::unique_ptr`, `std::shared_ptr` from ``) to automate memory management and reduce errors, but understanding `new` and `delete` is fundamental.

Passing Arguments by Reference.

One of the primary uses of references is to allow functions to modify the original arguments passed to them. This is called pass by reference.

To pass by reference, you declare the function parameter as a reference type (`type& paramName`).

#include <iostream>

// Function takes an integer by reference
void increment(int& num) {
    num++; // Modifies the original variable passed as argument
    std::cout << "Inside function, num = " << num << std::endl;
}

int main() {
    int value = 5;
    std::cout << "Before call, value = " << value << std::endl; // Output: 5

    increment(value); // Pass 'value'. The function receives a reference to it.
                      // Output: Inside function, num = 6

    std::cout << "After call, value = " << value << std::endl; // Output: 6 (original value was modified)
    return 0;
}

Pass by reference is more efficient than pass by value for large objects as it avoids copying the entire object. It's also necessary when a function needs to alter the state of the caller's variables.

You can also pass by const reference (`const type& paramName`) when you want the efficiency of avoiding a copy but also want to guarantee that the function will not modify the original argument.