Manuale completo di C++

// Il primo programma in C++
#include <iostream>   // libreria input/output

int main() {
    std::cout << "Ciao, mondo!" << std::endl;
    return 0;              // 0 = successo
}

#include <iostream>   // include libreria standard
#include "miofile.h"   // include file locale
#define PI 3.14159      // macro (sconsigliato in C++ moderno)
#define MAX(a,b) ((a)>(b)?(a):(b))

// Modo esplicito (consigliato)
std::cout << "Ciao";

// Oppure con using (accettabile in file .cpp piccoli)
using namespace std;
cout << "Ciao";

// Oppure selettivo (ideale)
using std::cout;
using std::endl;

int main() {
    // codice qui
    return 0;   // 0 = successo, altro = errore
}

// Con argomenti da riga di comando
int main(int argc, char* argv[]) {
    // argc = numero argomenti
    // argv = array di stringhe
    return 0;
}

// Commento su una riga

/* Commento
   su più righe */

/** Documentazione Doxygen
 *  @param x valore di input
 *  @return il doppio di x
 */
int doppio(int x) { return x * 2; }

// Dichiarazione (senza valore: contiene spazzatura!)
int a;

// Inizializzazione con =
int b = 10;

// Inizializzazione con {} (C++11, consigliata)
int c{20};

// Inizializzazione con ()
int d(30);

// Multipla
int x = 1, y = 2, z = 3;

// Costanti
const int MAX = 100;
// MAX = 200; // ERRORE: non modificabile

// constexpr: valutata a compile-time (C++11)
constexpr double PI = 3.14159;

auto n = 42;          // int
auto pi = 3.14;       // double
auto c = 'A';         // char
auto ok = true;       // bool
auto nome = std::string("Marco"); // std::string

int i = 42;
double d = i;                // conversione implicita: 42.0
int j = (int)3.99;          // cast stile C: j = 3
int k = static_cast<int>(3.99); // cast C++ (consigliato): k = 3
double x = static_cast<double>(7) / 2; // 3.5

#include <iostream>
using namespace std;

int main() {
    cout << "Ciao" << endl;              // Ciao + a capo
    cout << "Ciao\n";                     // stessa cosa
    cout << "Ho " << 17 << " anni" << endl;
    cout << "Pi greco = " << 3.14159 << endl;
    return 0;
}

#include <iostream>
using namespace std;

int main() {
    int eta;
    double altezza;
    char iniziale;

    cout << "Quanti anni hai? ";
    cin >> eta;

    cout << "Quanto sei alto (m)? ";
    cin >> altezza;

    cout << "Iniziale del nome? ";
    cin >> iniziale;

    cout << "\nCiao " << iniziale << ", hai " << eta
         << " anni e sei alto " << altezza << " m" << endl;
    return 0;
}

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

int main() {
    string nomeCompleto;
    cout << "Come ti chiami (nome e cognome)? ";
    getline(cin, nomeCompleto);
    cout << "Ciao, " << nomeCompleto << "!" << endl;
    return 0;
}

#include <iostream>
#include <iomanip>  // per setw, setprecision
using namespace std;

int main() {
    double pi = 3.14159265358979;

    cout << setprecision(4) << pi << endl;   // 3.142

    // Allineamento in colonna con setw
    cout << setw(10) << "Nome" << setw(10) << "Età" << endl;
    cout << setw(10) << "Marco" << setw(10) << 17 << endl;
    cout << setw(10) << "Sofia" << setw(10) << 16 << endl;
    return 0;
}

int x = 5;
if (x > 0 && x < 10) {
    cout << "x è una cifra" << endl;
}

// Short-circuit: se ptr è nullptr, non valuta ptr->valore
if (ptr != nullptr && ptr->valore > 0) {
    // ...
}

int x = 10;
x += 5;   // x = x + 5  → 15
x -= 3;   // x = x - 3  → 12
x *= 2;   // x = x * 2  → 24
x /= 4;   // x = x / 4  → 6
x %= 4;   // x = x % 4  → 2

int voto = 7;

if (voto >= 6) {
    cout << "Promosso" << endl;
} else {
    cout << "Bocciato" << endl;
}

// if annidati
if (voto >= 9) {
    cout << "Eccellente" << endl;
} else if (voto >= 7) {
    cout << "Buono" << endl;
} else if (voto >= 6) {
    cout << "Sufficiente" << endl;
} else {
    cout << "Insufficiente" << endl;
}

// condizione ? valore_se_vero : valore_se_falso
int a = 10, b = 20;
int max = (a > b) ? a : b;   // 20

int voto = 5;
string esito = (voto >= 6) ? "Promosso" : "Bocciato";

char scelta = 'B';

switch (scelta) {
    case 'A':
        cout << "Hai scelto A" << endl;
        break;   // senza break, "cade" nel case successivo
    case 'B':
    case 'C':
        cout << "Hai scelto B o C" << endl;
        break;
    default:
        cout << "Scelta non valida" << endl;
}

// Stampa 0, 1, 2, 3, 4
for (int i = 0; i < 5; i++) {
    cout << i << " ";
}
cout << endl;

// Con passo diverso
for (int i = 0; i <= 100; i += 10) {
    cout << i << " ";   // 0 10 20 30 ... 100
}

// Conteggio alla rovescia
for (int i = 10; i > 0; i--) {
    cout << i << " ";
}

int i = 0;
while (i < 5) {
    cout << i << " ";
    i++;
}
// Output: 0 1 2 3 4

// Legge numeri finché non viene inserito 0
int n;
while (true) {
    cout << "Numero (0 per uscire): ";
    cin >> n;
    if (n == 0) break;
    cout << "Hai inserito: " << n << endl;
}

int scelta;
do {
    cout << "1) Gioca  2) Esci: ";
    cin >> scelta;
    if (scelta == 1) cout << "Stai giocando..." << endl;
} while (scelta != 2);
cout << "Arrivederci!" << endl;

int voti[] = {6, 7, 8, 5, 9};

// for-each su array
for (int v : voti) {
    cout << v << " ";   // 6 7 8 5 9
}

// Con auto e modifica
for (auto& v : voti) {
    v += 1;    // modifica l'array originale
}

// Stampa solo i numeri dispari da 1 a 10
for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) continue;  // salta i pari
    cout << i << " ";
}

// Esce quando trova il numero 5
for (int i = 1; i <= 10; i++) {
    if (i == 5) break;
    cout << i << " ";    // 1 2 3 4
}

// Tabellina pitagorica 5x5
for (int i = 1; i <= 5; i++) {
    for (int j = 1; j <= 5; j++) {
        cout << setw(4) << (i * j);
    }
    cout << endl;
}

// Array di 5 interi, non inizializzati
int voti[5];

// Inizializzazione completa
int a[5] = {10, 20, 30, 40, 50};

// Inizializzazione parziale (resto a 0)
int b[5] = {1, 2};   // {1, 2, 0, 0, 0}

// Tutti a zero
int c[5] = {0};

// Dimensione dedotta dal compilatore
int d[] = {1, 2, 3};   // dimensione 3

// std::array (C++11, dimensione nota a compile-time)
#include <array>
std::array<int, 5> arr = {1, 2, 3, 4, 5};

int a[5] = {10, 20, 30, 40, 50};

cout << a[0] << endl;   // 10 (primo elemento)
cout << a[4] << endl;   // 50 (ultimo elemento)

a[2] = 99;             // modifica il terzo elemento

// Iterazione con for classico
for (int i = 0; i < 5; i++) {
    cout << a[i] << " ";
}

// Iterazione con for-each
for (int x : a) {
    cout << x << " ";
}

// Matrice 3x4
int m[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

// Stampa la matrice
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 4; j++) {
        cout << setw(4) << m[i][j];
    }
    cout << endl;
}

int a[] = {4, 7, 1, 9, 3, 5};
int n = sizeof(a) / sizeof(a[0]);   // 6

// Somma
int somma = 0;
for (int x : a) somma += x;
cout << "Somma: " << somma << endl;   // 29

// Media
double media = static_cast<double>(somma) / n;
cout << "Media: " << media << endl;

// Massimo e minimo
int max = a[0], min = a[0];
for (int i = 1; i < n; i++) {
    if (a[i] > max) max = a[i];
    if (a[i] < min) min = a[i];
}

// Ricerca lineare
int cercato = 9;
int pos = -1;
for (int i = 0; i < n; i++) {
    if (a[i] == cercato) {
        pos = i;
        break;
    }
}
if (pos != -1) cout << "Trovato in posizione " << pos << endl;

// Ricerca del valore massimo e sua posizione
int posMax = 0;
for (int i = 1; i < n; i++) {
    if (a[i] > a[posMax]) posMax = i;
}

// Inversione (reverse) in-place
for (int i = 0; i < n / 2; i++) {
    int temp = a[i];
    a[i] = a[n - 1 - i];
    a[n - 1 - i] = temp;
}

// Ordinamento a bolle (bubble sort)
for (int i = 0; i < n - 1; i++) {
    for (int j = 0; j < n - 1 - i; j++) {
        if (a[j] > a[j + 1]) {
            int temp = a[j];
            a[j] = a[j + 1];
            a[j + 1] = temp;
        }
    }
}

#include <cstring>
char nome[20] = "Marco";     // 5 char + '\0'
char saluto[] = "Ciao";      // dimensione dedotta

// Funzioni della libreria <cstring>
std::strlen(nome);              // lunghezza: 5
std::strcpy(dest, src);         // copia
std::strcat(dest, src);         // concatena
std::strcmp(a, b);              // confronta: 0 se uguali

#include <string>
#include <iostream>

std::string nome = "Marco";
std::string cognome = "Rossi";

// Concatenazione
std::string completo = nome + " " + cognome;   // "Marco Rossi"

// Lunghezza
std::cout << completo.length() << std::endl;   // 11
std::cout << completo.size() << std::endl;     // 11 (alias)

// Accesso ai caratteri
std::cout << nome[0] << std::endl;          // 'M'
std::cout << nome.at(1) << std::endl;        // 'a' (con controllo limiti)

// Confronto
if (nome == "Marco") std::cout << "Uguale";

// Sottostringa
std::string sub = completo.substr(0, 5);   // "Marco"

// Ricerca
size_t pos = completo.find("Rossi");     // 6

// Inserimento e cancellazione
completo.insert(0, "Sig. ");            // "Sig. Marco Rossi"
completo.erase(0, 5);                   // "Marco Rossi"
completo.replace(0, 5, "Luca");          // "Luca Rossi"

// Da numero a stringa
std::string s = std::to_string(42);       // "42"
std::string pi = std::to_string(3.14);    // "3.140000"

// Da stringa a numero (C++11)
int n = std::stoi("42");               // 42
double d = std::stod("3.14");          // 3.14
long long ll = std::stoll("9999999999");

// Dichiarazione (prototipo) — dice al compilatore che esiste
int somma(int a, int b);

// Definizione — il corpo della funzione
int somma(int a, int b) {
    return a + b;
}

int main() {
    int r = somma(3, 5);   // chiamata
    std::cout << r << std::endl; // 8
    return 0;
}

void perValore(int x)      { x = 100; }              // copia, non cambia fuori
void perRiferimento(int& x) { x = 100; }              // modifica l'originale
void perPuntatore(int* p)  { *p = 100; }             // modifica tramite puntatore

int main() {
    int a = 1;
    perValore(a);        // a resta 1
    perRiferimento(a);   // a diventa 100
    perPuntatore(&a);   // a resta 100
    return 0;
}

void saluta(std::string nome, std::string saluto = "Ciao") {
    std::cout << saluto << ", " << nome << std::endl;
}

saluta("Marco");              // Ciao, Marco
saluta("Marco", "Buongiorno"); // Buongiorno, Marco

int    somma(int a, int b)             { return a + b; }
double somma(double a, double b)       { return a + b; }
int    somma(int a, int b, int c)       { return a + b + c; }

std::cout << somma(2, 3);        // 5 (int)
std::cout << somma(2.5, 3.1);    // 5.6 (double)
std::cout << somma(1, 2, 3);     // 6

// Fattoriale ricorsivo
long long fattoriale(int n) {
    if (n <= 1) return 1;         // caso base
    return n * fattoriale(n - 1);      // passo ricorsivo
}

// Fibonacci ricorsivo
int fib(int n) {
    if (n <= 1) return n;
    return fib(n-1) + fib(n-2);
}

int a = 42;
int* p = &a;      // p contiene l'indirizzo di a

std::cout << a << std::endl;   // 42
std::cout << p << std::endl;   // 0x7ffee... (indirizzo)
std::cout << *p << std::endl;  // 42 (valore puntato)

*p = 100;               // modifica a tramite p
std::cout << a << std::endl;   // 100

int* p = nullptr;   // C++11, preferito

if (p != nullptr) {
    std::cout << *p;   // solo se non è nullo
}

// Mai dereferenziare un puntatore nullo! Undefined behavior.

int arr[5] = {10, 20, 30, 40, 50};
int* p = arr;         // punta al primo elemento

std::cout << *p << std::endl;       // 10
std::cout << *(p + 1) << std::endl;   // 20
std::cout << p[2] << std::endl;      // 30 (equivalente a *(p+2))

// Scorrimento con puntatore
for (int* q = arr; q != arr + 5; q++) {
    std::cout << *q << " ";
}

int a = 10;
int& r = a;    // r è un alias di a

r = 20;         // modifica a
std::cout << a << std::endl;   // 20

// Una reference DEVE essere inizializzata
// int& r; // ERRORE

// Una reference NON può essere riassegnata
int b = 30;
r = b;         // copia il valore di b in a, non cambia il riferimento!
std::cout << a << std::endl;   // 30

// Efficiente: non copia la stringa, non può modificarla
void stampa(const std::string& s) {
    std::cout << s << std::endl;
    // s = "ciao"; // ERRORE: const
}

// Accetta sia lvalue che rvalue
std::string nome = "Marco";
stampa(nome);              // OK
stampa("Ciao mondo");      // OK (temporaneo)

struct Punto {
    double x;
    double y;
};

int main() {
    Punto p1;               // dichiarazione
    p1.x = 3.0;
    p1.y = 4.0;

    Punto p2 = {1.0, 2.0};   // inizializzazione
    Punto p3{5.0, 6.0};        // C++11

    std::cout << p1.x << "," << p1.y << std::endl;   // 3,4
    return 0;
}

struct Data {
    int giorno, mese, anno;
};

struct Studente {
    std::string nome;
    int matricola;
    Data nascita;
    double voti[5];
};

Studente s;
s.nome = "Marco";
s.matricola = 12345;
s.nascita.giorno = 15;
s.nascita.mese = 3;
s.nascita.anno = 2008;
s.voti[0] = 8.5;

// Array di struct
Studente classe[25];

struct Punto { double x, y; };

// Passaggio per riferimento per modificare
void sposta(Punto& p, double dx, double dy) {
    p.x += dx;
    p.y += dy;
}

// Passaggio per const reference per leggere (efficiente)
double distanza(const Punto& a, const Punto& b) {
    double dx = a.x - b.x;
    double dy = a.y - b.y;
    return std::sqrt(dx*dx + dy*dy);
}

class ContoBancario {
private:
    std::string intestatario;
    double saldo;

public:
    // Costruttore
    ContoBancario(std::string nome, double iniziale) {
        intestatario = nome;
        saldo = iniziale;
    }

    // Metodi
    void deposita(double importo) {
        if (importo > 0) saldo += importo;
    }

    bool preleva(double importo) {
        if (importo > saldo) return false;
        saldo -= importo;
        return true;
    }

    double getSaldo() const { return saldo; }
    std::string getIntestatario() const { return intestatario; }
};

int main() {
    ContoBancario c("Marco", 100.0);
    c.deposita(50);
    c.preleva(30);
    std::cout << c.getSaldo() << std::endl;   // 120
    // c.saldo = 0; // ERRORE: privato
    return 0;
}

class Rettangolo {
private:
    double base, altezza;
public:
    // Costruttore di default
    Rettangolo() : base(1), altezza(1) {}

    // Costruttore con parametri (lista di inizializzazione)
    Rettangolo(double b, double h) : base(b), altezza(h) {}

    // Distruttore (chiamato automaticamente alla fine)
    ~Rettangolo() {
        std::cout << "Distrutto" << std::endl;
    }

    double area() const { return base * altezza; }
};

Rettangolo r1;             // 1x1
Rettangolo r2(5, 3);      // 5x3
Rettangolo r3{4, 2};      // C++11

class Animale {
protected:
    std::string nome;
public:
    Animale(std::string n) : nome(n) {}

    virtual void verso() const {
        std::cout << "..." << std::endl;
    }

    virtual ~Animale() {}   // distruttore virtuale (importante!)
};

class Cane : public Animale {
public:
    Cane(std::string n) : Animale(n) {}

    void verso() const override {
        std::cout << "Bau!" << std::endl;
    }
};

class Gatto : public Animale {
public:
    Gatto(std::string n) : Animale(n) {}
    void verso() const override { std::cout << "Miao" << std::endl; }
};

int main() {
    Cane c("Rex");
    Gatto g("Whiskers");
    c.verso();   // Bau!
    g.verso();   // Miao

    // Polimorfismo
    Animale* a = &c;
    a->verso();   // Bau! (grazie a virtual)
}

#include <vector>

// Dichiarazione e inizializzazione
std::vector<int> v;                // vuoto
std::vector<int> v2 = {1, 2, 3};
std::vector<int> v3(5, 10);       // 5 elementi tutti = 10

// Aggiungere elementi
v.push_back(42);              // aggiunge in coda
v.push_back(43);

// Rimuovere l'ultimo
v.pop_back();

// Accesso
v[0] = 100;                 // no controllo limiti
v.at(0) = 200;              // con controllo, lancia eccezione

// Dimensione
std::cout << v.size() << std::endl;
std::cout << v.empty() << std::endl;   // true se vuoto

// Iterazione
for (int x : v) std::cout << x << " ";

// Con indice
for (size_t i = 0; i < v.size(); i++)
    std::cout << v[i] << " ";

// Svuotare
v.clear();

#include <vector>
#include <iostream>
#include <algorithm>

std::vector<int> voti = {6, 7, 9, 5, 8};

// Somma e media
int somma = 0;
for (int v : voti) somma += v;
double media = static_cast<double>(somma) / voti.size();

// Massimo (con algorithm)
int massimo = *std::max_element(voti.begin(), voti.end());

// Ordinamento (con algorithm)
std::sort(voti.begin(), voti.end());

#include <map>

std::map<std::string, int> eta;

// Inserimento
eta["Marco"] = 17;
eta["Sofia"] = 16;
eta["Luca"]  = 18;

// Accesso
std::cout << eta["Marco"] << std::endl;   // 17

// Ricerca sicura
auto it = eta.find("Anna");
if (it != eta.end()) {
    std::cout << it->second << std::endl;
} else {
    std::cout << "Non trovato" << std::endl;
}

// Conteggio occorrenze (molto comune)
std::map<std::string, int> conteggio;
std::string parola;
while (std::cin >> parola) {
    conteggio[parola]++;   // incrementa (crea a 0 se assente)
}

// Iterazione (le chiavi sono ordinate!)
for (const auto& [chiave, valore] : conteggio) {
    std::cout << chiave << ": " << valore << std::endl;
}

#include <set>

std::set<int> s;
s.insert(3);
s.insert(1);
s.insert(2);
s.insert(1);   // duplicato, ignorato

// Ricerca
if (s.count(2)) std::cout << "Contiene 2";

// Iterazione (ordine crescente)
for (int x : s) std::cout << x << " ";   // 1 2 3

#include <algorithm>
#include <vector>

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

// Ordinamento (O(n log n))
std::sort(v.begin(), v.end());

// Ordine decrescente
std::sort(v.begin(), v.end(), std::greater<int>());

// Minimo e massimo
auto min = std::min_element(v.begin(), v.end());
auto max = std::max_element(v.begin(), v.end());

// Ricerca
auto it = std::find(v.begin(), v.end(), 8);

// Conteggio
int n = std::count(v.begin(), v.end(), 3);

// Somma (in <numeric>)
#include <numeric>
int somma = std::accumulate(v.begin(), v.end(), 0);

// Inversione
std::reverse(v.begin(), v.end());

// Rimuovere duplicati (dopo sort)
v.erase(std::unique(v.begin(), v.end()), v.end());

// Trasformazione (map)
std::vector<int> doppi(v.size());
std::transform(v.begin(), v.end(), doppi.begin(),
              [](int x) { return x * 2; });

// Funzione generica per il massimo
template<typename T>
T massimo(T a, T b) {
    return (a > b) ? a : b;
}

std::cout << massimo(3, 7) << std::endl;         // 7 (int)
std::cout << massimo(3.14, 2.71) << std::endl;   // 3.14 (double)
std::cout << massimo(std::string("a"), std::string("b"));

// Una coppia generica
template<typename K, typename V>
class Coppia {
private:
    K chiave;
    V valore;
public:
    Coppia(K k, V v) : chiave(k), valore(v) {}
    K getChiave() const { return chiave; }
    V getValore() const { return valore; }
};

Coppia<std::string, int> p("Marco", 17);
std::cout << p.getChiave() << " ha " << p.getValore() << " anni";

#include <stdexcept>

double dividi(double a, double b) {
    if (b == 0) {
        throw std::invalid_argument("Divisione per zero");
    }
    return a / b;
}

int main() {
    try {
        double r = dividi(10, 0);
        std::cout << r << std::endl;
    }
    catch (const std::exception& e) {
        std::cout << "Errore: " << e.what() << std::endl;
    }
    return 0;
}

try {
    int n = std::stoi("abc");   // lancia invalid_argument
} catch (const std::invalid_argument& e) {
    std::cout << "Formato non valido: " << e.what() << std::endl;
} catch (const std::out_of_range& e) {
    std::cout << "Numero troppo grande: " << e.what() << std::endl;
} catch (...) {
    std::cout << "Errore sconosciuto" << std::endl;
}

#include <fstream>
#include <iostream>

std::ofstream file("output.txt");

if (!file.is_open()) {
    std::cerr << "Impossibile aprire il file" << std::endl;
    return 1;
}

file << "Ciao, file!" << std::endl;
file << 42 << " " << 3.14 << std::endl;
file.close();   // chiusura esplicita (o automatica alla distruzione)

#include <fstream>
#include <iostream>
#include <string>

std::ifstream file("input.txt");

if (!file.is_open()) {
    std::cerr << "File non trovato" << std::endl;
    return 1;
}

// Leggere parola per parola
std::string parola;
while (file >> parola) {
    std::cout << parola << std::endl;
}

// Leggere riga per riga
std::string riga;
while (std::getline(file, riga)) {
    std::cout << riga << std::endl;
}

file.close();

// Aggiungi a un file esistente
std::ofstream log("log.txt", std::ios::app);
log << "Nuova riga di log" << std::endl;

// File binario
std::ofstream bin("data.bin", std::ios::binary);

// Singolo oggetto
int* p = new int(42);
std::cout << *p << std::endl;
delete p;   // libera la memoria

// Array dinamico
int n = 10;
int* arr = new int[n];
for (int i = 0; i < n; i++) arr[i] = i * 2;
delete[] arr;   // attenzione alle parentesi quadre!

// Oggetto di classe
auto* p2 = new std::string("Ciao");
delete p2;

// Memory leak
int* p1 = new int(10);
// ... dimentico delete

// Double free: libero due volte
int* p2 = new int(20);
delete p2;
// delete p2;   // ERRORE: double free

// Dangling pointer: uso dopo delete
int* p3 = new int(30);
delete p3;
// std::cout << *p3;  // ERRORE: memoria non più valida

#include <memory>

// Creazione
std::unique_ptr<int> p = std::make_unique<int>(42);
std::cout << *p << std::endl;

// Array
auto arr = std::make_unique<int[]>(5);
arr[0] = 10;

// Non serve delete!
// Quando p esce dallo scope, libera la memoria automaticamente

// Trasferimento di proprietà (move)
std::unique_ptr<int> q = std::move(p);   // ora q possiede l'oggetto, p è vuoto

auto p1 = std::make_shared<int>(100);
std::shared_ptr<int> p2 = p1;   // condivide

std::cout << p1.use_count() << std::endl;   // 2
*p2 = 200;                                // modifica per tutti

p1.reset();
std::cout << p2.use_count() << std::endl;   // 1

// auto deduce il tipo
auto n = 42;              // int
auto pi = 3.14;           // double
auto nome = std::string("Marco");

// Range-for
std::vector<int> v = {1, 2, 3};
for (auto x : v) std::cout << x << " ";

// Modifica con auto&
for (auto& x : v) x *= 2;

// Lambda base
auto somma = [](int a, int b) { return a + b; };
std::cout << somma(3, 4) << std::endl;   // 7

// Lambda con cattura per riferimento
int contatore = 0;
auto incrementa = [&contatore]() { contatore++; };
incrementa();
incrementa();
std::cout << contatore << std::endl;   // 2

// Uso con sort per ordinamento custom
std::vector<std::string> nomi = {"Marco", "Anna", "Luca"};
std::sort(nomi.begin(), nomi.end(),
         [](const std::string& a, const std::string& b) {
             return a.size() < b.size();   // ordina per lunghezza
         });

// Iterare una map in modo pulito
std::map<std::string, int> eta = {{"Marco", 17}, {"Sofia", 16}};

for (const auto& [nome, anni] : eta) {
    std::cout << nome << ": " << anni << std::endl;
}

// Con pair
auto [min, max] = std::minmax(5, 3);

constexpr int quadrato(int x) { return x * x; }
constexpr int risultato = quadrato(5);   // calcolato a compile-time

biblioteca/
├── main.cpp
├── libro.hpp / libro.cpp
├── biblioteca.hpp / biblioteca.cpp
└── libri.txt (file dati)

#pragma once
#include <string>

class Libro {
private:
    std::string titolo;
    std::string autore;
    std::string isbn;
    bool disponibile;

public:
    Libro() : disponibile(true) {}
    Libro(const std::string& t, const std::string& a, const std::string& i)
        : titolo(t), autore(a), isbn(i), disponibile(true) {}

    std::string getTitolo() const { return titolo; }
    std::string getAutore() const { return autore; }
    std::string getISBN() const { return isbn; }
    bool isDisponibile() const { return disponibile; }

    void presta()   { disponibile = false; }
    void restituisci() { disponibile = true; }

    std::string toString() const;
};

#include "libro.hpp"
#include <sstream>

std::string Libro::toString() const {
    std::ostringstream oss;
    oss << "[" << (disponibile ? "DISP" : "PREST") << "] "
        << titolo << " - " << autore << " (ISBN: " << isbn << ")";
    return oss.str();
}

#pragma once
#include "libro.hpp"
#include <vector>
#include <string>

class Biblioteca {
private:
    std::vector<Libro> libri;
    const std::string nomeFile = "libri.txt";

public:
    void aggiungi(const Libro& l);
    void presta(const std::string& isbn);
    void restituisci(const std::string& isbn);
    std::vector<Libro> cercaPerAutore(const std::string& autore) const;
    void stampaTutti() const;

    void salva() const;
    void carica();
};

#include "biblioteca.hpp"
#include <iostream>
#include <fstream>
#include <sstream>
#include <stdexcept>
#include <algorithm>

void Biblioteca::aggiungi(const Libro& l) {
    auto it = std::find_if(libri.begin(), libri.end(),
        [&l](const Libro& x) { return x.getISBN() == l.getISBN(); });
    if (it != libri.end())
        throw std::runtime_error("ISBN già esistente");
    libri.push_back(l);
}

void Biblioteca::presta(const std::string& isbn) {
    for (auto& l : libri) {
        if (l.getISBN() == isbn) {
            if (!l.isDisponibile())
                throw std::runtime_error("Libro già in prestito");
            l.presta();
            return;
        }
    }
    throw std::runtime_error("Libro non trovato");
}

void Biblioteca::restituisci(const std::string& isbn) {
    for (auto& l : libri) {
        if (l.getISBN() == isbn) {
            l.restituisci();
            return;
        }
    }
    throw std::runtime_error("Libro non trovato");
}

std::vector<Libro> Biblioteca::cercaPerAutore(const std::string& autore) const {
    std::vector<Libro> risultato;
    std::copy_if(libri.begin(), libri.end(), std::back_inserter(risultato),
        [&autore](const Libro& l) { return l.getAutore() == autore; });
    return risultato;
}

void Biblioteca::stampaTutti() const {
    if (libri.empty()) {
        std::cout << "Nessun libro in biblioteca.\n";
        return;
    }
    for (const auto& l : libri)
        std::cout << l.toString() << std::endl;
}

void Biblioteca::salva() const {
    std::ofstream f(nomeFile);
    for (const auto& l : libri) {
        f << l.getTitolo() << "|" << l.getAutore() << "|"
          << l.getISBN() << "|" << l.isDisponibile() << std::endl;
    }
}

void Biblioteca::carica() {
    std::ifstream f(nomeFile);
    if (!f.is_open()) return;
    std::string riga;
    while (std::getline(f, riga)) {
        std::istringstream iss(riga);
        std::string titolo, autore, isbn, disp;
        std::getline(iss, titolo, '|');
        std::getline(iss, autore, '|');
        std::getline(iss, isbn, '|');
        std::getline(iss, disp);
        Libro l(titolo, autore, isbn);
        if (disp == "0") l.presta();
        libri.push_back(l);
    }
}

#include "biblioteca.hpp"
#include <iostream>
#include <limits>

void menu() {
    std::cout << "\n=== BIBLIOTECA ===\n"
              << "1) Aggiungi libro\n"
              << "2) Presta libro\n"
              << "3) Restituisci libro\n"
              << "4) Cerca per autore\n"
              << "5) Elenco libri\n"
              << "0) Esci\n"
              << "Scelta: ";
}

int main() {
    Biblioteca b;
    b.carica();

    int scelta;
    while (true) {
        menu();
        if (!(std::cin >> scelta)) break;
        std::cin.ignore();

        try {
            if (scelta == 1) {
                std::string t, a, i;
                std::cout << "Titolo: "; std::getline(std::cin, t);
                std::cout << "Autore: "; std::getline(std::cin, a);
                std::cout << "ISBN:   "; std::getline(std::cin, i);
                b.aggiungi(Libro(t, a, i));
                std::cout << "Libro aggiunto.\n";
            }
            else if (scelta == 2) {
                std::string i;
                std::cout << "ISBN: "; std::getline(std::cin, i);
                b.presta(i);
                std::cout << "Libro prestato.\n";
            }
            else if (scelta == 3) {
                std::string i;
                std::cout << "ISBN: "; std::getline(std::cin, i);
                b.restituisci(i);
                std::cout << "Libro restituito.\n";
            }
            else if (scelta == 4) {
                std::string autore;
                std::cout << "Autore: "; std::getline(std::cin, autore);
                for (const auto& l : b.cercaPerAutore(autore))
                    std::cout << l.toString() << std::endl;
            }
            else if (scelta == 5) {
                b.stampaTutti();
            }
            else if (scelta == 0) {
                break;
            }
        }
        catch (const std::exception& e) {
            std::cout << "Errore: " << e.what() << std::endl;
        }
    }

    b.salva();
    std::cout << "Dati salvati. Arrivederci!\n";
    return 0;
}