Learning Modern C++

Modern C++ emphasizes automatic memory management through RAII (Resource Acquisition Is Initialization). Variables should be initialized properly to avoid undefined behavior.

#include 
#include 

int main() {
    // Stack variables (automatic lifetime)
    int x = 42;
    double pi = 3.14159;
    
    // Smart pointers (RAII - automatic cleanup)
    std::unique_ptr ptr(new int(100));
    std::shared_ptr str = std::make_shared("hello");
    
    // String (manages memory automatically)
    std::string message = "Modern C++";
    
    // No manual delete needed!
    return 0;
}

Key Point: Never use raw pointers for ownership. Use unique_ptr for exclusive ownership, shared_ptr for shared ownership.

Move semantics enable efficient transfer of resources. Understanding lvalues vs rvalues unlocks performance gains.

class Buffer {
    std::vector data;
public:
    // Move constructor (steal resources)
    Buffer(Buffer&& other) noexcept 
        : data(std::move(other.data)) {}
    
    // Move assignment
    Buffer& operator=(Buffer&& other) noexcept {
        data = std::move(other.data);
        return *this;
    }
};

Buffer create_buffer() {
    Buffer b;
    return b;  // Calls move constructor (cheap!)
}

Key Point: Move semantics avoid expensive copies. Compiler uses RVO/NRVO when possible.

OOP in C++ uses virtual functions for runtime polymorphism. Prefer composition over deep inheritance hierarchies.

class Shape {
public:
    virtual ~Shape() = default;
    virtual double area() const = 0;
    virtual void draw() const = 0;
};

class Circle : public Shape {
    double radius;
public:
    Circle(double r) : radius(r) {}
    double area() const override { 
        return 3.14159 * radius * radius; 
    }
    void draw() const override { 
        std::cout << "Drawing circle\n"; 
    }
};

// Usage
std::unique_ptr shape = std::make_unique(5.0);
std::cout << shape->area() << "\n";
shape->draw();

Key Point: Mark overrides with override keyword. Use virtual and = 0 for pure virtual methods.

Templates provide compile-time polymorphism. C++20 Concepts make template errors readable.

#include 

// Concept: anything printable
template
concept Printable = requires(T t, std::ostream& os) {
    { os << t } -> std::convertible_to;
};

// Generic function using concept
template
void print_all(const std::vector& items) {
    for (const auto& item : items) {
        std::cout << item << "\n";
    }
}

int main() {
    std::vector nums = {1, 2, 3};
    print_all(nums);  // Works!
    
    struct Foo {};
    std::vector foos;
    print_all(foos);  // Compile error: Foo is not Printable
}

Key Point: Concepts enable generic programming with clear constraints.

STL provides optimized data structures and algorithms. Choose the right container for your use case.

#include 
#include 
#include 

int main() {
    // Vector: contiguous, fast random access
    std::vector nums = {3, 1, 4, 1, 5};
    std::sort(nums.begin(), nums.end());
    
    // Map: ordered key-value pairs
    std::unordered_map counts;
    counts["apple"]++;
    counts["banana"]++;
    
    // Algorithms with lambdas
    auto sum = 0;
    std::for_each(nums.begin(), nums.end(), 
        [&sum](int n) { sum += n; });
    
    std::cout << "Sum: " << sum << "\n";
}

Key Point: Use range-based for loops and STL algorithms for safer, cleaner code.

Modern C++ provides std::thread for concurrent programming. Use mutexes and atomics for thread-safe access.

#include 
#include 

std::mutex mtx;
int shared_value = 0;

void increment() {
    for (int i = 0; i < 1000; ++i) {
        std::lock_guard lock(mtx);
        shared_value++;
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    
    t1.join();
    t2.join();
    
    std::cout << "Final value: " << shared_value << "\n";
}

Key Point: Use std::lock_guard for RAII-based mutex management. Avoid manual lock/unlock.