C++ Moderno

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

int main() {
    // auto deduce il tipo dal valore iniziale
    auto x = 42;          // int
    auto y = 3.14;        // double
    auto z = 3.14f;       // float
    auto s = "ciao"s;     // std::string (con suffisso s, C++14)
    auto b = true;        // bool

    cout << typeid(x).name() << "\n"; // i (int)

    // Molto utile per tipi complessi
    map<string, vector<int>> mappa;
    mappa["a"] = {1, 2, 3};

    // Senza auto:
    // map<string, vector<int>>::iterator it = mappa.begin();
    // Con auto:
    auto it = mappa.begin();

    // decltype: deduce il tipo di un'espressione
    int a=5, b2=10;
    decltype(a + b2) risultato = a + b2;  // int
    cout << risultato << "\n";

    // Range-based for loop (C++11) — usa auto
    vector<int> v = {1, 2, 3, 4, 5};

    for (auto elem : v) cout << elem << " ";  // Copia
    cout << "\n";

    for (auto &elem : v) elem *= 2;            // Modifica (reference)
    for (const auto &elem : v) cout << elem << " ";  // Sola lettura
    cout << "\n";

    // auto con const e reference
    const auto &ci = v[0];  // const int&
    auto *ptr = &a;          // int*

    return 0;
}

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

int main() {
    // Sintassi: [capture](params) -> return_type { body }

    // Lambda semplice
    auto saluta = [](const string &nome) {
        cout << "Ciao " << nome << "!\n";
    };
    saluta("Mario");

    // Lambda con valore di ritorno esplicito
    auto somma = [](int a, int b) -> int { return a + b; };
    cout << somma(3, 4) << "\n";

    // Capture by value [=]
    int base = 10;
    auto aggiungi_base = [base](int x) { return x + base; };
    // base viene copiato al momento della creazione della lambda

    // Capture by reference [&]
    int contatore = 0;
    auto incrementa = [&contatore]() { contatore++; };
    incrementa(); incrementa(); incrementa();
    cout << "Contatore: " << contatore << "\n";  // 3

    // Capture tutto: [=] copia tutto, [&] reference a tutto
    int a=1, b2=2;
    auto tutto_per_valore = [=]() { return a + b2; };
    auto tutto_per_ref    = [&]() { a++; b2++; };

    // Lambda mutabile (può modificare le copie)
    int n = 5;
    auto inc = [n]() mutable { n++; return n; };
    cout << inc() << "\n";  // 6 (ma n esterno rimane 5)
    cout << n << "\n";      // 5

    // Uso con algoritmi STL — il caso d'uso più comune
    vector<int> v = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};

    // Sort personalizzato
    sort(v.begin(), v.end(), [](int a, int b) { return a > b; }); // Decrescente

    // Count_if
    int pari = count_if(v.begin(), v.end(), [](int x) { return x % 2 == 0; });
    cout << "Numeri pari: " << pari << "\n";

    // Transform
    vector<int> quadrati(v.size());
    transform(v.begin(), v.end(), quadrati.begin(), [](int x) { return x*x; });

    // Lambda generica (C++14) — usa auto come parametro
    auto massimo = [](auto a, auto b) { return a > b ? a : b; };
    cout << massimo(3, 5) << "\n";
    cout << massimo(3.14, 2.71) << "\n";
    cout << massimo(string("abc"), string("xyz")) << "\n";

    // std::function per salvare lambda
    function<int(int)> fib = [&fib](int n) -> int {
        return n <= 1 ? n : fib(n-1) + fib(n-2);
    };
    cout << "fib(10) = " << fib(10) << "\n";

    return 0;
}

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

class Buffer {
    int *dati;
    size_t size;
public:
    Buffer(size_t n) : dati(new int[n]), size(n) {
        cout << "Costruttore: alloca " << n << " int\n";
    }

    // Copy constructor: O(n) — copia i dati
    Buffer(const Buffer &altro) : dati(new int[altro.size]), size(altro.size) {
        memcpy(dati, altro.dati, size * sizeof(int));
        cout << "Copy constructor: COPIA " << size << " int\n";
    }

    // Move constructor: O(1) — prende i puntatori
    Buffer(Buffer &&altro) noexcept : dati(altro.dati), size(altro.size) {
        altro.dati = nullptr;  // Invalida l'originale
        altro.size = 0;
        cout << "Move constructor: SPOSTA (nessuna copia!)\n";
    }

    // Move assignment
    Buffer &operator=(Buffer &&altro) noexcept {
        if (this != &altro) {
            delete[] dati;
            dati = altro.dati;
            size = altro.size;
            altro.dati = nullptr;
            altro.size = 0;
            cout << "Move assignment\n";
        }
        return *this;
    }

    ~Buffer() {
        if (dati) delete[] dati;
    }

    size_t getSize() const { return size; }
};

Buffer crea_buffer(size_t n) {
    Buffer buf(n);  // Costruisce
    return buf;     // Move avviene automaticamente (NRVO/RVO)
}

int main() {
    Buffer b1(100);                  // Costruttore
    Buffer b2 = b1;                  // Copy constructor
    Buffer b3 = move(b1);            // Move constructor — b1 è ora invalido
    Buffer b4 = crea_buffer(50);     // Move (o RVO: ottimizzato dal compilatore)

    cout << "b2.size = " << b2.getSize() << "\n";
    cout << "b3.size = " << b3.getSize() << "\n";  // 100
    cout << "b1.size = " << b1.getSize() << "\n";  // 0 (spostato!)

    // std::move con i container
    vector<int> v1 = {1, 2, 3, 4, 5};
    vector<int> v2 = move(v1);  // O(1) — sposta il puntatore interno
    cout << "v1.size=" << v1.size() << " v2.size=" << v2.size() << "\n";

    return 0;
}

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

// ===== Structured Bindings (C++17) =====
tuple<int, string, double> get_info() {
    return {42, "Mario", 99.5};
}

// ===== std::optional — valore che potrebbe non esistere =====
optional<int> cerca_elemento(const vector<int> &v, int target) {
    for (int i=0; i<(int)v.size(); i++)
        if (v[i] == target) return i;  // Restituisce l'indice
    return nullopt;  // Non trovato
}

// ===== std::variant — union type-safe =====
using Numero = variant<int, double, string>;

void stampa_numero(const Numero &n) {
    if (holds_alternative<int>(n))         cout << "int: "    << get<int>(n);
    else if (holds_alternative<double>(n))  cout << "double: " << get<double>(n);
    else                                    cout << "string: " << get<string>(n);
    cout << "\n";
}

// ===== if constexpr (C++17) — branching a compile time =====
template<typename T>
void stampa_tipo(T val) {
    if constexpr (is_integral_v<T>)
        cout << "Intero: " << val << "\n";
    else if constexpr (is_floating_point_v<T>)
        cout << "Decimale: " << val << "\n";
    else
        cout << "Altro: " << val << "\n";
}

int main() {
    // Structured bindings
    auto [id, nome, voto] = get_info();
    cout << id << " " << nome << " " << voto << "\n";

    // Loop su map con structured bindings
    map<string, int> voti = {{"Mario",30}, {"Anna",28}, {"Luca",25}};
    for (const auto &[nome2, v] : voti) {
        cout << nome2 << ": " << v << "\n";
    }

    // std::optional
    vector<int> v = {1, 5, 3, 8, 2};
    if (auto pos = cerca_elemento(v, 8)) {
        cout << "Trovato alla posizione " << *pos << "\n";
    } else {
        cout << "Non trovato\n";
    }

    // optional con value_or
    auto r = cerca_elemento(v, 99);
    cout << "Posizione (o -1): " << r.value_or(-1) << "\n";

    // std::variant
    Numero n1 = 42;
    Numero n2 = 3.14;
    Numero n3 = string("hello");
    stampa_numero(n1);
    stampa_numero(n2);
    stampa_numero(n3);

    // if constexpr
    stampa_tipo(42);
    stampa_tipo(3.14);
    stampa_tipo(string("test"));

    return 0;
}

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

class Vettore {
    vector<double> dati;
public:
    // Costruttore con initializer_list
    Vettore(initializer_list<double> lista) : dati(lista) {}

    double norma() const {
        double s = 0;
        for (double d : dati) s += d*d;
        return sqrt(s);
    }

    void stampa() const {
        cout << "[";
        for (size_t i=0; i<dati.size(); i++) {
            if (i) cout << ", ";
            cout << dati[i];
        }
        cout << "]";
    }
};

struct Punto { int x, y, z; };

int main() {
    // Uniform initialization con {}
    int a{42};           // Come int a = 42
    double b{3.14};
    string s{"ciao"};
    vector<int> v{1,2,3,4,5};
    Punto p{1, 2, 3};   // Aggregate init

    // Importante: {} impedisce narrowing conversion!
    // int x{3.14};  // ERRORE di compilazione (perdi dati)
    // int x = 3.14; // OK (ma warning) — troncamento silenzioso

    // nullptr (C++11) — sostituisce NULL
    int *ptr = nullptr;       // Meglio di: int *ptr = NULL o int *ptr = 0
    if (!ptr) cout << "Puntatore nullo\n";

    // Initializer list personalizzata
    Vettore v1{1.0, 2.0, 3.0};
    v1.stampa();
    cout << " — norma: " << v1.norma() << "\n";

    // Range-based for con initializer_list inline
    for (int x : {10, 20, 30, 40, 50}) cout << x << " ";
    cout << "\n";

    return 0;
}

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

// constexpr: calcolata a compile time
constexpr int fattoriale(int n) {
    return n <= 1 ? 1 : n * fattoriale(n-1);
}

constexpr int fibonacci(int n) {
    if (n <= 1) return n;
    return fibonacci(n-1) + fibonacci(n-2);  // C++14 permette if in constexpr
}

// Calcola potenze di 2 a compile time
constexpr int potenza2(int n) { return n == 0 ? 1 : 2 * potenza2(n-1); }

// constexpr if (C++17)
template<typename T>
constexpr bool e_intero = is_integral_v<T>;

int main() {
    // Calcolato a compile time — nessuna runtime computation!
    constexpr int f10 = fattoriale(10);
    constexpr int fib15 = fibonacci(15);
    constexpr int p10 = potenza2(10);

    cout << "10! = " << f10 << "\n";        // 3628800
    cout << "fib(15) = " << fib15 << "\n"; // 610
    cout << "2^10 = " << p10 << "\n";       // 1024

    // Usabile come dimensione di array a compile time
    array<int, fattoriale(5)> arr;  // array di 120 elementi
    cout << "Array size: " << arr.size() << "\n";

    // constexpr vs #define
    // #define MAX 100        // Nessun tipo, problematico
    constexpr int MAX = 100;  // Ha tipo, debuggabile, namespace-safe

    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <ranges>
#include <format>   // C++20
#include <concepts> // C++20
using namespace std;

// Concepts: vincoli sui template (C++20)
template<typename T>
concept Numerico = is_arithmetic_v<T>;

template<Numerico T>
T somma(T a, T b) { return a + b; }

// Range-based programming (C++20)
void demo_ranges() {
    vector<int> v = {5,3,8,1,9,2,7,4,6};

    // Filtra e trasforma in modo dichiarativo
    auto risultato = v
        | views::filter([](int x){ return x % 2 == 0; })   // Pari
        | views::transform([](int x){ return x * x; });    // Elevati al quadrato

    for (int x : risultato) cout << x << " ";
    cout << "\n";

    // Prendi i primi 3
    auto primi3 = v | views::take(3);
    for (int x : primi3) cout << x << " ";
    cout << "\n";
}

// std::format (C++20) — come Python f-string
void demo_format() {
    string nome = "Mario";
    int eta = 30;
    double pi = 3.14159;

    // Simile a printf ma type-safe
    cout << format("Nome: {}, Età: {}\n", nome, eta);
    cout << format("Pi: {:.4f}\n", pi);
    cout << format("Hex: {:#x}\n", 255);
    cout << format("Larghezza: {:>10}\n", "destra");
}

int main() {
    // Concepts
    cout << somma(3, 4) << "\n";        // OK: int
    cout << somma(1.5, 2.7) << "\n";    // OK: double
    // somma(string("a"), string("b")); // ERRORE: non soddisfa Numerico

    // Ranges
    demo_ranges();

    // Format (richiedono compilatore recente)
    // demo_format();

    return 0;
}