C++ Next Steps

This shift toward "let the type manage the resource" is called RAII (Resource Acquisition Is Initialization). A resource – memory, a file handle, a network socket – is acquired in a constructor and released in a destructor. Because C++ guarantees destructors run when an object leaves scope (even during an exception), RAII types cannot leak the resource they own. Every tool described below – vectors, strings, smart pointers, file streams – is built on this one idea.

Syntax: A Preview of What’s Coming

You do not need to memorize these yet – this table is a map, not a lesson. Each row is a topic worth studying next, with a taste of its syntax.

Examples

Example 1: auto and range-based for

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> scores = {88, 92, 79, 95, 60};
    int total = 0;
    for (auto score : scores) {
        total += score;
    }
    double average = static_cast<double>(total) / scores.size();
    cout << "Average score: " << average << endl;
    return 0;
}

Output:

Average score: 82.8

Here auto lets the compiler figure out that score is an int, and the range-based for loop walks through every element of scores without you writing an index variable or comparing against .size() manually. This is the same total-and-divide logic you already know, just written with less ceremony and no chance of an off-by-one indexing bug.

Example 2: Smart pointers and RAII

#include <iostream>
#include <memory>
#include <string>
using namespace std;

class Robot {
public:
    Robot(string name) : name(name) {
        cout << name << " has been activated." << endl;
    }
    ~Robot() {
        cout << name << " has been shut down." << endl;
    }
    void greet() {
        cout << "Beep boop, I am " << name << "." << endl;
    }
private:
    string name;
};

int main() {
    unique_ptr<Robot> r1 = make_unique<Robot>("R2D2");
    r1->greet();
    return 0;
}

Output:

R2D2 has been activated.
Beep boop, I am R2D2.
R2D2 has been shut down.

make_unique<Robot>("R2D2") allocates a Robot on the heap and hands ownership to r1. You never write new or delete yourself. When main ends and r1 goes out of scope, its destructor automatically deletes the Robot, which is why "shut down" prints without any explicit cleanup code. This is RAII in action: the lifetime of the heap object is tied to the lifetime of the pointer variable.

Example 3: Lambdas with STL algorithms

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    vector<int> nums = {5, 2, 9, 1, 7};
    sort(nums.begin(), nums.end(), [](int a, int b) {
        return a > b;
    });
    cout << "Sorted descending: ";
    for (int n : nums) {
        cout << n << " ";
    }
    cout << endl;

    int count = count_if(nums.begin(), nums.end(), [](int n) {
        return n > 4;
    });
    cout << "Numbers greater than 4: " << count << endl;
    return 0;
}

Output:

Sorted descending: 9 7 5 2 1 
Numbers greater than 4: 3

The lambda [](int a, int b) { return a > b; } is a small, unnamed function passed directly to std::sort to control the ordering – no separate comparator function needed. The second lambda is passed to std::count_if, which counts how many elements satisfy a condition. Once you are comfortable with lambdas, most hand-written loops for searching, filtering, and transforming data can be replaced by a single call to an STL algorithm.

Under the Hood

It helps to know what these tools actually cost at runtime, since that is often the first question intermediate programmers ask.

std::vector stores its elements in one contiguous heap block, exactly like a hand-managed dynamic array. When it runs out of capacity, it allocates a new, larger block (typically growing by 1.5x-2x), copies or moves the old elements over, and frees the old block – this is why appending to a vector is usually O(1) but occasionally triggers an O(n) reallocation.

std::unique_ptr is a thin wrapper around a raw pointer with almost no runtime overhead: it is typically the same size as the raw pointer it holds, and its destructor is a single conditional delete. It cannot be copied (only moved), which is exactly what enforces "single owner" semantics at compile time.

A lambda expression compiles down to an anonymous class (a "closure type") with an operator() and, if it captures variables, member fields holding those captured values. [](int a, int b) { ... } with empty brackets captures nothing, so it compiles to essentially a plain function pointer with zero overhead. A lambda like [total](int x) captures total by value, generating a hidden class field to store that copy.

Common Mistakes

Mistake 1: Manual memory management instead of a container.

int* scores = new int[5]{90, 85, 77, 92, 88};
int total = 0;
for (int i = 0; i < 5; i++) {
    total += scores[i];
}
cout << "Total: " << total << endl;
// missing delete[] scores; -> the array is leaked

This compiles and runs fine, but the array allocated with new[] is never freed with delete[]. In a short-lived program this leak is invisible; in a long-running program (a server, a game loop) leaks like this accumulate until memory runs out. The fix is to stop managing the array by hand and let a container own it:

vector<int> scores = {90, 85, 77, 92, 88};
int total = 0;
for (int s : scores) {
    total += s;
}
cout << "Total: " << total << endl;

Both print Total: 432, but the second version has no new, no delete, and no possibility of a leak – vector‘s destructor cleans up automatically.

Mistake 2: Copying instead of referencing in a range-based for loop.

vector<string> names = {"Alice", "Bob", "Charlotte"};
for (auto name : names) {
    name += "!";
}
for (const auto& name : names) {
    cout << name << " ";
}
cout << endl;

This prints Alice Bob Charlotte – unchanged – even though the intent was clearly to append "!" to every name. The bug is that auto name : names makes name a fresh copy of each string; modifying the copy does nothing to the original vector. The fix is to loop by reference:

vector<string> names = {"Alice", "Bob", "Charlotte"};
for (auto& name : names) {
    name += "!";
}
for (const auto& name : names) {
    cout << name << " ";
}
cout << endl;

Now it prints Alice! Bob! Charlotte! , because auto& binds directly to each element instead of copying it. As a rule of thumb: use auto& when you intend to modify elements, and const auto& when you only need to read them (this also avoids unnecessary copying of large objects).

Best Practices

• Prefer std::vector, std::string, and other STL containers over raw arrays and manual new/delete – they manage memory correctly by construction.
• Reach for std::unique_ptr when you need a heap object with a single clear owner, and std::shared_ptr only when ownership is genuinely shared between multiple parts of the program.
• Use const auto& in range-based for loops by default; switch to auto& only when you need to modify elements, and plain auto only for small, cheap-to-copy types like int.
• Learn the STL algorithms header (<algorithm>) early – sort, find, count_if, accumulate, and transform replace the majority of hand-written loops you have been writing.
• Read compiler warnings, not just errors – many bugs like Mistake 2 above compile cleanly but produce warnings that hint at the problem.
• Once comfortable, study move semantics (std::move, rvalue references) – it is the mechanism that lets containers and smart pointers transfer ownership cheaply instead of copying.
• Pick one small project (a to-do list, a text-based game, a simple parser) and rebuild it using vectors, smart pointers, and lambdas instead of raw arrays and pointers – applying a concept is what makes it stick.

Practice Exercises

Exercise 1: Write a program that stores five temperatures in a std::vector<double>, then uses a range-based for loop to print the highest temperature without using std::max_element (track the maximum manually as you loop).

Exercise 2: Rewrite a program that currently uses int* arr = new int[10]; to instead use a std::vector<int>, and confirm you no longer need a delete[] anywhere.

Exercise 3: Using std::sort with a lambda, sort a std::vector<string> of names by length (shortest first) instead of alphabetically. Hint: your lambda should compare a.size() and b.size().

Summary

• Everything you learned about pointers, memory, and control flow is still the foundation – modern C++ tools are built on top of it, not instead of it.
• RAII (Resource Acquisition Is Initialization) is the core idea behind vectors, strings, and smart pointers: a resource is freed automatically when its owning object goes out of scope.
• std::unique_ptr and std::vector eliminate most manual new/delete bugs, including leaks and double-frees.
• Lambda expressions are small inline functions, most useful when paired with STL algorithms like sort, find, and count_if.
• Prefer const auto& in loops to avoid accidental copies, and reach for auto& only when you intend to modify elements.
• The best way to internalize these tools is to rebuild a small project you already understand using them instead of raw arrays and pointers.