Modern C++#

#include <memory>

auto user = std::make_unique<User>("Alice", 30);  // allocates on heap
user->greet();  // use like a raw pointer

// Automatically deleted when unique_ptr goes out of scope
// Cannot be copied — only moved
auto user2 = std::move(user);  // user is now nullptr

auto data = std::make_shared<std::vector<int>>(1000);
auto copy = data;  // reference count = 2

data.use_count();  // 2
// Deleted when last shared_ptr is destroyed

std::weak_ptr<User> observer = shared_user;
if (auto locked = observer.lock()) {
    // locked is a shared_ptr — object still alive
    locked->greet();
}
// If the object was deleted, lock() returns nullptr

std::vector<int> create_data() {
    std::vector<int> v(1000000);
    // ... fill v ...
    return v;  // MOVED, not copied (compiler optimises this — NRVO)
}

std::string a = "hello";
std::string b = std::move(a);  // a is now in a "valid but unspecified" state
// a might be empty, or might contain something — don't use it

void process(const std::string& s);   // accepts lvalues (named variables)
void process(std::string&& s);         // accepts rvalues (temporaries, std::move'd)

// Basic lambda
auto add = [](int a, int b) { return a + b; };
add(3, 4);  // 7

// Capture by reference
int threshold = 10;
auto above = [&threshold](int x) { return x > threshold; };

// Capture by value
auto snapshot = [threshold](int x) { return x > threshold; };

// Capture all by reference
auto f = [&](int x) { return x + threshold; };

// Capture all by value
auto g = [=](int x) { return x + threshold; };

// Generic lambda (C++14)
auto print = [](const auto& x) { std::cout << x << std::endl; };

std::vector<int> v = {5, 3, 1, 4, 2};

std::sort(v.begin(), v.end(), [](int a, int b) { return a > b; });
// v = {5, 4, 3, 2, 1}

auto it = std::find_if(v.begin(), v.end(), [](int x) { return x == 3; });

int sum = std::accumulate(v.begin(), v.end(), 0,
    [](int acc, int x) { return acc + x; });

auto x = 42;                          // int
auto pi = 3.14;                       // double
auto name = std::string("Alice");     // std::string
auto v = std::vector<int>{1, 2, 3};   // std::vector<int>

// With references
const auto& ref = v;                  // const std::vector<int>&

// Return type deduction (C++14)
auto add(int a, int b) { return a + b; }

// Structured bindings (C++17)
std::map<std::string, int> ages = {{"Alice", 30}, {"Bob", 25}};
for (const auto& [name, age] : ages) {
    std::cout << name << ": " << age << std::endl;
}

#include <optional>

std::optional<User> find_user(int id) {
    if (/* found */) return User{...};
    return std::nullopt;
}

auto user = find_user(42);
if (user.has_value()) {
    std::cout << user->name() << std::endl;
}

// Or with value_or
std::string name = find_user(42)
    .transform([](const User& u) { return u.name(); })
    .value_or("unknown");

#include <variant>

std::variant<int, double, std::string> value;
value = 42;
value = "hello";

// Visit pattern
std::visit([](const auto& v) {
    std::cout << v << std::endl;
}, value);

// Type check
if (std::holds_alternative<int>(value)) {
    int n = std::get<int>(value);
}

constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

constexpr int result = factorial(10);  // computed at compile time
static_assert(factorial(5) == 120);    // compile-time assertion

// constexpr if (C++17) — compile-time branch
template<typename T>
std::string to_string(T value) {
    if constexpr (std::is_same_v<T, bool>) {
        return value ? "true" : "false";
    } else {
        return std::to_string(value);
    }
}