Modern C++ Features (C++11 to C++20)

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

int main() {
    // auto deduces the type
    auto x = 42;          // int
    auto pi = 3.14;       // double
    auto name = "Arjun"s; // string (with s suffix)

    // Range-based for loop (replaces iterator boilerplate)
    vector<int> v = {10, 20, 30, 40, 50};
    for (auto val : v)
        cout << val << " ";
    cout << endl;

    // By reference (avoids copy)
    for (auto& val : v)
        val *= 2;
    for (const auto& val : v)
        cout << val << " ";
    cout << endl;

    // Uniform initialization with braces
    int a{42};
    vector<int> w{1, 2, 3, 4, 5};
    map<string, int> marks{{"Arjun", 85}, {"Priya", 92}};

    // auto with iterators (no more verbose type names)
    auto it = marks.find("Arjun");
    if (it != marks.end())
        cout << it->first << ": " << it->second << endl;

    return 0;
}

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

int main() {
    // Basic lambda: [capture](params) -> return_type { body }
    auto square = [](int x) { return x * x; };
    cout << "square(5) = " << square(5) << endl;

    // Capture by value [=] and by reference [&]
    int factor = 3;
    auto multiply = [factor](int x) { return x * factor; };
    cout << "multiply(7) = " << multiply(7) << endl;

    // Capture by reference to modify
    int total = 0;
    vector<int> v = {1, 2, 3, 4, 5};
    for_each(v.begin(), v.end(), [&total](int x) { total += x; });
    cout << "Total: " << total << endl;

    // Lambda as comparator for sort
    vector<pair<string, int>> students = {
        {"Arjun", 85}, {"Priya", 92}, {"Kiran", 78}
    };
    sort(students.begin(), students.end(),
        [](const pair<string, int>& a, const pair<string, int>& b) {
            return a.second > b.second;  // sort by marks descending
        });
    for (auto& [name, marks] : students)
        cout << name << ": " << marks << endl;

    // Mutable lambda (modify captured-by-value variables)
    int counter = 0;
    auto inc = [counter]() mutable { return ++counter; };
    cout << inc() << " " << inc() << " " << inc() << endl;
    cout << "Original counter: " << counter << endl;  // unchanged

    return 0;
}

#include <iostream>
using namespace std;

// nullptr replaces NULL
void process(int n) { cout << "int: " << n << endl; }
void process(int* p) { cout << "pointer: " << p << endl; }

// enum class: strongly typed, no implicit conversion
enum class Color { Red, Green, Blue };
enum class Size { Small, Medium, Large };

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

constexpr int fibonacci(int n) {
    if (n <= 1) return n;
    int a = 0, b = 1;
    for (int i = 2; i <= n; i++) {
        int temp = a + b;
        a = b;
        b = temp;
    }
    return b;
}

int main() {
    // nullptr: unambiguous null pointer
    int* ptr = nullptr;
    // process(NULL);    // Ambiguous! NULL is 0 (int)
    process(nullptr);    // Calls process(int*)
    process(42);         // Calls process(int)

    // enum class: scoped, no implicit int conversion
    Color c = Color::Red;
    // int x = c;        // ERROR: no implicit conversion
    int x = static_cast<int>(c);  // Explicit: 0
    cout << "Color value: " << x << endl;

    // constexpr: evaluated at compile time
    constexpr int fact5 = factorial(5);   // Computed at compile time!
    constexpr int fib10 = fibonacci(10);  // Also compile time
    cout << "5! = " << fact5 << endl;
    cout << "fib(10) = " << fib10 << endl;

    // constexpr array size
    constexpr int N = 1024;
    int arr[N];  // Valid: N is known at compile time
    cout << "Array size: " << N << endl;

    return 0;
}

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

int main() {
    // Generic lambda (C++14): auto parameters
    auto print = [](auto x) { cout << x << " "; };
    print(42);       // int
    print(3.14);     // double
    print("hello");  // const char*
    cout << endl;

    // Generic lambda as comparator
    auto maxOf = [](auto a, auto b) { return (a > b) ? a : b; };
    cout << "max(3, 7) = " << maxOf(3, 7) << endl;
    cout << "max(3.14, 2.71) = " << maxOf(3.14, 2.71) << endl;

    // Return type deduction (C++14)
    auto add = [](auto a, auto b) { return a + b; };
    cout << "add(2, 3) = " << add(2, 3) << endl;
    cout << "add(2.5, 3.7) = " << add(2.5, 3.7) << endl;
    cout << "add strings: " << add(string("Hello"), string(" World")) << endl;

    // C++14: auto return type deduction for functions
    // auto multiply(int a, int b) { return a * b; }  // Valid in C++14

    // Generic lambda for sorting any vector
    auto sortAndPrint = [](auto& vec) {
        sort(vec.begin(), vec.end());
        for (const auto& x : vec) cout << x << " ";
        cout << endl;
    };

    vector<int> ints = {5, 3, 1, 4, 2};
    vector<string> strs = {"Kiran", "Arjun", "Priya"};
    sortAndPrint(ints);
    sortAndPrint(strs);

    return 0;
}

#include <iostream>
#include <map>
#include <optional>
#include <string>
#include <tuple>
using namespace std;

// Function returning optional (may or may not have a value)
optional<int> findIndex(const vector<int>& v, int target) {
    for (int i = 0; i < (int)v.size(); i++)
        if (v[i] == target) return i;
    return nullopt;  // No value
}

tuple<string, int, double> getStudent() {
    return {"Arjun", 85, 9.2};
}

int main() {
    // Structured bindings: unpack pairs, tuples, structs
    auto [name, marks, gpa] = getStudent();
    cout << name << ": " << marks << ", GPA: " << gpa << endl;

    // Structured bindings with maps
    map<string, int> scores = {{"Arjun", 85}, {"Priya", 92}, {"Kiran", 78}};
    for (auto& [student, score] : scores)
        cout << student << ": " << score << endl;

    // If with initializer (C++17)
    if (auto it = scores.find("Priya"); it != scores.end())
        cout << "Found Priya: " << it->second << endl;
    else
        cout << "Priya not found" << endl;
    // it is not accessible here (scoped to the if)

    // std::optional
    vector<int> v = {10, 20, 30, 40, 50};
    auto result = findIndex(v, 30);
    if (result.has_value())
        cout << "Found at index: " << result.value() << endl;
    else
        cout << "Not found" << endl;

    auto missing = findIndex(v, 99);
    cout << "99 found? " << missing.has_value() << endl;
    cout << "Default: " << missing.value_or(-1) << endl;

    return 0;
}

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

// string_view: non-owning reference to string data (zero-copy)
void greet(string_view name) {
    cout << "Hello, " << name << "!" << endl;
}

// Count words without copying the string
int countWords(string_view text) {
    int count = 0;
    bool inWord = false;
    for (char c : text) {
        if (c != ' ' && !inWord) { count++; inWord = true; }
        else if (c == ' ') inWord = false;
    }
    return count;
}

// using alias (C++11): cleaner than typedef
using StringVec = vector<string>;
using ScoreMap = map<string, int>;
template<typename T>
using Vec = vector<T>;  // Template alias!

int main() {
    // string_view works with string, const char*, and substrings
    string s = "Vikram Sharma";
    greet(s);              // From string
    greet("Priya");        // From literal (no string construction!)

    string_view sv = s;
    cout << "First name: " << sv.substr(0, 6) << endl;  // Zero-copy substring
    cout << "Words: " << countWords("Modern C++ is powerful") << endl;

    // using aliases in action
    StringVec names = {"Arjun", "Priya", "Kiran"};
    Vec<int> numbers = {1, 2, 3, 4, 5};  // Template alias
    for (auto& name : names) cout << name << " ";
    cout << endl;

    return 0;
}

#include <iostream>
#include <concepts>
#include <compare>
#include <string>
using namespace std;

// Concept: constrain template parameters
template<typename T>
concept Numeric = is_arithmetic_v<T>;

template<typename T>
concept Printable = requires(T t) {
    { cout << t } -> same_as<ostream&>;
};

// Function using concept (clear error messages!)
template<Numeric T>
T add(T a, T b) {
    return a + b;
}

// Abbreviated function template with auto + concept
void printValue(Printable auto val) {
    cout << "Value: " << val << endl;
}

// Spaceship operator <=> : three-way comparison
struct Student {
    string name;
    int marks;

    // Compiler generates ==, !=, <, >, <=, >= from <=>
    auto operator<=>(const Student&) const = default;
};

struct Score {
    int value;
    // Custom spaceship: compare by value
    auto operator<=>(const Score& other) const {
        return value <=> other.value;
    }
    bool operator==(const Score& other) const = default;
};

int main() {
    // Concepts in action
    cout << add(3, 4) << endl;       // OK: int is Numeric
    cout << add(2.5, 3.7) << endl;   // OK: double is Numeric
    // add("a", "b");                // ERROR: string is not Numeric (clear message!)

    printValue(42);
    printValue("hello");

    // Spaceship operator
    Student s1{"Arjun", 85}, s2{"Priya", 92};
    cout << (s1 < s2) << endl;   // Compares name first, then marks

    Score a{85}, b{92}, c{85};
    cout << (a < b) << " " << (a == c) << " " << (b > a) << endl;

    // Three-way comparison result
    auto result = a <=> b;
    if (result < 0) cout << "a < b" << endl;
    else if (result > 0) cout << "a > b" << endl;
    else cout << "a == b" << endl;

    return 0;
}

#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <memory>
#include <numeric>
using namespace std;

int main() {
    // === VARIABLE DECLARATION ===
    // Old: explicit types everywhere
    map<string, vector<int>>::iterator oldIt;
    // Modern: auto
    auto modernMap = map<string, vector<int>>{{"Arjun", {85, 90, 78}}};
    auto it = modernMap.begin();

    // === ITERATION ===
    vector<int> v = {1, 2, 3, 4, 5};
    // Old:
    for (vector<int>::iterator i = v.begin(); i != v.end(); ++i)
        cout << *i << " ";
    cout << endl;
    // Modern:
    for (auto x : v) cout << x << " ";
    cout << endl;

    // === NULL POINTER ===
    // Old: NULL (which is 0, an int)
    int* oldPtr = NULL;
    // Modern: nullptr (type-safe)
    int* newPtr = nullptr;

    // === FUNCTION OBJECTS ===
    // Old: write a whole struct
    struct OldCompare {
        bool operator()(int a, int b) { return a > b; }
    };
    sort(v.begin(), v.end(), OldCompare());
    // Modern: lambda
    sort(v.begin(), v.end(), [](int a, int b) { return a > b; });

    // === MEMORY MANAGEMENT ===
    // Old: raw new/delete
    int* oldArr = new int[5];
    delete[] oldArr;
    // Modern: smart pointer
    auto smartArr = make_unique<int[]>(5);

    // === TYPE ALIASES ===
    // Old: typedef
    typedef vector<pair<string, int>> OldType;
    // Modern: using
    using ModernType = vector<pair<string, int>>;

    cout << "Modern C++ is cleaner and safer!" << endl;
    return 0;
}