Advanced C++ Concepts

What are Advanced C++ Concepts?

This tutorial dives into advanced C++ concepts that enable you to write more efficient, powerful, and scalable C++ code. It covers advanced techniques and language features that transform you from an intermediate to an advanced C++ developer.

Advanced C++ concepts are features and techniques that provide:

• Enhanced code flexibility.
• Better memory management.
• High-performance programming.
• Modern C++ techniques (C++11, C++14, C++17, C++20, and beyond).

Key Advanced C++ Concepts

1. Smart Pointers (Memory Management)
2. RAII (Resource Acquisition Is Initialization)
3. Move Semantics and R-value References
4. Perfect Forwarding
5. Lambda Expressions (Functional Programming)
6. Function Objects (Functors)
7. Type Deduction (auto, decltype)
8. SFINAE (Substitution Failure Is Not An Error)
9. Advanced Template Programming (Variadic Templates, Concepts)
10. Inline Namespaces
11. Advanced Error Handling (Custom Exceptions, noexcept)
12. CRTP (Curiously Recurring Template Pattern)
13. Multi-threading with std::async and std::future
14. Metaprogramming (constexpr, consteval, and constinit)
15. C++ Modules (C++20)

1. Smart Pointers (Memory Management)

Smart pointers are part of the <memory> header and automatically manage memory, ensuring that memory is properly freed.

Types of Smart Pointers:

• std::unique_ptr: Manages unique ownership (only one pointer can own the resource).
• std::shared_ptr: Manages shared ownership (multiple pointers can share the resource).
• std::weak_ptr: Manages a weak reference (does not own the resource, but can observe it).

➡️ Example: Unique Pointer

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

int main() {
    unique_ptr<int> ptr = make_unique<int>(10);
    cout << "Unique Pointer Value: " << *ptr << endl;
    return 0;
}

Output:

Unique Pointer Value: 10

➡️ Example: Shared Pointer

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

int main() {
    shared_ptr<int> sp1 = make_shared<int>(20);
    shared_ptr<int> sp2 = sp1; // Shared ownership

    cout << "Shared Pointer Value: " << *sp1 << endl;
    cout << "Reference Count: " << sp1.use_count() << endl;
    return 0;
}

Output:

Shared Pointer Value: 20
Reference Count: 2

2. RAII (Resource Acquisition Is Initialization)

• RAII is a programming idiom where resource allocation is tied to the lifespan of an object.
• Resources (memory, file handles, sockets) are acquired and released automatically.

➡️ Example: RAII for File Management

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

class FileManager {
    ofstream file;
public:
    FileManager(const string &filename) {
        file.open(filename);
        cout << "File opened." << endl;
    }

    ~FileManager() {
        file.close();
        cout << "File closed." << endl;
    }
};

int main() {
    {
        FileManager fm("example.txt");
    } // FileManager goes out of scope here
    return 0;
}

Output:

File opened.
File closed.

3. Move Semantics and R-value References

• Move semantics optimize resource management for temporary objects.
• R-value references (T&&) allow efficient transfer of resources without copying.

➡️ Example: Move Semantics

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

int main() {
    vector<int> vec1 = {1, 2, 3};
    vector<int> vec2 = move(vec1); // Move resources

    cout << "vec1 size: " << vec1.size() << endl;
    cout << "vec2 size: " << vec2.size() << endl;
    return 0;
}

Output:

vec1 size: 0
vec2 size: 3

4. Perfect Forwarding

• Perfect forwarding is a technique used with templates to forward arguments exactly as received.
• It is typically used in function templates with std::forward.

➡️ Example:

#include <iostream>
using namespace std;

template <typename T>
void print(T &&value) {
    cout << "Value: " << value << endl;
}

int main() {
    int x = 42;
    print(x);        // L-value
    print(42);       // R-value
    return 0;
}

Output:

Value: 42
Value: 42

5. Lambda Expressions

• Lambda expressions are anonymous functions that can be used directly within the code.
• Syntax: [capture list](parameters) -> return type { body }.

➡️ Example: Basic Lambda

#include <iostream>
using namespace std;

int main() {
    auto sum = [](int a, int b) -> int {
        return a + b;
    };

    cout << "Sum: " << sum(5, 3) << endl;
    return 0;
}

Output:

Sum: 8

6. Function Objects (Functors)

• A functor is an object that can be called like a function.
• Typically implemented using operator() in a class.

➡️ Example:

#include <iostream>
using namespace std;

class Multiply {
public:
    int operator()(int a, int b) {
        return a * b;
    }
};

int main() {
    Multiply multiply;
    cout << "Multiplication: " << multiply(4, 5) << endl;
    return 0;
}

Output:

Multiplication: 20

7. Type Deduction (auto, decltype)

• auto automatically deduces the type of a variable.
• decltype deduces the type of an expression without evaluating it.

➡️ Example:

#include <iostream>
using namespace std;

int main() {
    auto x = 10;
    decltype(x) y = 20;
    cout << "x: " << x << ", y: " << y << endl;
    return 0;
}

Output:

x: 10, y: 20

8. SFINAE (Substitution Failure Is Not An Error)

• SFINAE is a technique used in templates where an invalid substitution does not result in a compilation error.

➡️ Example:

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

template <typename T>
typename enable_if<is_integral<T>::value, T>::type
printValue(T value) {
    cout << "Integer Value: " << value << endl;
}

int main() {
    printValue(42);
    // printValue(3.14); // Error: Not an integer
    return 0;
}

Output:

Integer Value: 42