Advertisement
Mini Course

Learn C++ Advanced: Master Advanced Techniques

65 min course • Updated: January 2024

You've mastered intermediate C++. Now let's dive into advanced topics - templates, the STL, move semantics, and modern C++ features. These are what separate good C++ programmers from experts.

This course assumes you're comfortable with intermediate C++. If you're not, check out our intermediate course first.

Lesson 1: Templates

Templates let you write generic code that works with any type: 

template <typename T>
T maximum(T a, T b) {
    return (a > b) ? a : b;
}

// Use with different types
cout << maximum(5, 10) << endl;        // 10
cout << maximum(3.5, 2.1) << endl;     // 3.5
cout << maximum('a', 'z') << endl;     // z

// Class template
template <typename T>
class Stack {
private:
    vector<T> elements;
public:
    void push(T element) {
        elements.push_back(element);
    }
    T pop() {
        T element = elements.back();
        elements.pop_back();
        return element;
    }
};

Stack<int> intStack;
Stack<string> stringStack;

Templates let you write code once and use it with different types. The compiler generates the specific versions you need.

Lesson 2: STL Containers

The Standard Template Library has powerful containers: 

#include <vector>
#include <map>
#include <set>
#include <unordered_map>

// Map - key-value pairs
map<string, int> ages;
ages["Alice"] = 25;
ages["Bob"] = 30;
cout << ages["Alice"] << endl;  // 25

// Set - unique elements
set<int> numbers = {3, 1, 4, 1, 5};
// Only contains: 1, 3, 4, 5

// Unordered map - faster lookups
unordered_map<string, int> fastMap;
fastMap["key"] = 100;

STL containers are optimized and well-tested. Use them instead of implementing your own data structures.

Lesson 3: STL Algorithms

The STL has algorithms for common operations: 

#include <algorithm>
#include <vector>

vector<int> numbers = {5, 2, 8, 1, 9};

// Sort
sort(numbers.begin(), numbers.end());

// Find
auto it = find(numbers.begin(), numbers.end(), 8);

// Count
int count = count_if(numbers.begin(), numbers.end(), 
    [](int n) { return n > 5; });

// Transform
transform(numbers.begin(), numbers.end(), numbers.begin(),
    [](int n) { return n * 2; });

STL algorithms are efficient and well-tested. Learn them - they'll save you time and make your code better.

Lesson 4: Lambda Expressions

Lambdas are anonymous functions. Great for short operations: 

// Simple lambda
auto add = [](int a, int b) { return a + b; };
cout << add(5, 3) << endl;  // 8

// Lambda with capture
int multiplier = 2;
auto times = [multiplier](int x) { return x * multiplier; };
cout << times(5) << endl;  // 10

// Lambda in algorithm
vector<int> nums = {1, 2, 3, 4, 5};
for_each(nums.begin(), nums.end(), 
    [](int n) { cout << n * 2 << " "; });

Lambdas are perfect for short functions used once, especially with STL algorithms.

Advertisement

Lesson 5: Move Semantics

Move semantics avoid unnecessary copies. Important for performance: 

// Move constructor
class MyClass {
public:
    MyClass() { /* expensive initialization */ }
    MyClass(MyClass&& other) {  // Move constructor
        // Move resources from other
        // Much faster than copying
    }
};

vector<string> vec1 = {"large", "data"};
vector<string> vec2 = move(vec1);  // Move, don't copy
// vec1 is now empty, vec2 has the data

Move semantics let you transfer ownership of resources without copying. Much more efficient for large objects.

Lesson 6: RAII and Destructors

RAII (Resource Acquisition Is Initialization) manages resources automatically: 

class FileHandler {
private:
    ofstream file;
public:
    FileHandler(string filename) {
        file.open(filename);
    }
    ~FileHandler() {  // Destructor
        if (file.is_open()) {
            file.close();
        }
    }
    // File automatically closes when object is destroyed
};

{
    FileHandler fh("data.txt");
    // Use file
}  // File automatically closed here

RAII ensures resources are cleaned up automatically. Destructors run when objects go out of scope.

Lesson 7: Operator Overloading

Overload operators to make your classes work naturally: 

class Vector {
public:
    int x, y;
    Vector(int x, int y) : x(x), y(y) {}
    
    Vector operator+(const Vector& other) {
        return Vector(x + other.x, y + other.y);
    }
    
    bool operator==(const Vector& other) {
        return x == other.x && y == other.y;
    }
};

Vector v1(1, 2);
Vector v2(3, 4);
Vector v3 = v1 + v2;  // Works naturally

Operator overloading makes your classes work with built-in operators. Use it when it makes sense.

Lesson 8: Multithreading

C++11 added threading support: 

#include <thread>
#include <mutex>

mutex mtx;

void printNumbers(int start, int end) {
    for (int i = start; i <= end; i++) {
        lock_guard<mutex> lock(mtx);  // Automatic locking
        cout << i << " ";
    }
}

thread t1(printNumbers, 1, 5);
thread t2(printNumbers, 6, 10);
t1.join();
t2.join();

Multithreading lets you run code in parallel. Use mutexes to protect shared data. Be careful - threading is complex.

Best Practices

  • Use modern C++: C++11/14/17/20 have many improvements. Use them.
  • Prefer STL: Use STL containers and algorithms instead of writing your own.
  • Use smart pointers: Prefer smart pointers over raw pointers.
  • Follow RAII: Acquire resources in constructors, release in destructors.
  • Write clear code: Advanced features are powerful, but clarity matters more.

Pro Tip: Don't use every advanced feature just because you can. Use them when they solve real problems. Over-engineering is worse than under-engineering. Start simple, add complexity only when needed.

Common Questions

When should I use templates?

Use templates when you need the same code to work with different types. They're great for containers, algorithms, and utility functions. But don't overuse them - they can make code harder to read.

Should I learn all STL containers?

Learn the common ones: vector, map, set, unordered_map. You'll use these most. Learn others as you need them. The STL is huge - you don't need to know everything.

How do I get better at C++?

Write code. Build projects. Read code from experienced developers. Contribute to open-source C++ projects. The more you code, the better you get. There's no shortcut.

Keep Learning and Building

You've learned advanced C++ concepts. Now use them. Build projects that use templates, STL, and modern C++ features. Read code from experienced C++ developers. Contribute to open-source projects. The best way to master advanced concepts is to use them in real projects.

Related Articles

Advertisement