Template e STL

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

// Template di funzione: T è un tipo generico
template <typename T>
T massimo(T a, T b) {
    return (a > b) ? a : b;
}

// Template con più tipi
template <typename T, typename U>
void stampa_coppia(T a, U b) {
    cout << "(" << a << ", " << b << ")\n";
}

// Specializzazione esplicita per const char*
template <>
const char* massimo(const char *a, const char *b) {
    return (strlen(a) > strlen(b)) ? a : b;
}

// Template con parametro non-tipo
template <int N>
void ripeti(const string &s) {
    for (int i = 0; i < N; i++) cout << s << " ";
    cout << "\n";
}

int main() {
    cout << massimo(10, 20) << "\n";          // int
    cout << massimo(3.14, 2.71) << "\n";      // double
    cout << massimo('A', 'Z') << "\n";        // char
    cout << massimo("ciao", "mondo!") << "\n"; // specializzato

    stampa_coppia(42, "hello");
    stampa_coppia(3.14, true);

    ripeti<5>("Echo");

    return 0;
}

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

int main() {
    vector<int> v = {5, 2, 8, 1, 9, 3};

    v.push_back(7);         // Aggiunge in coda
    v.insert(v.begin(), 0); // Inserisce in posizione

    cout << "Size: " << v.size() << ", Capacity: " << v.capacity() << "\n";

    // Range-based for (C++11)
    for (int n : v) cout << n << " ";
    cout << "\n";

    // Algoritmi STL
    sort(v.begin(), v.end());                   // Ordina
    cout << "Ordinato: ";
    for (int n : v) cout << n << " ";
    cout << "\n";

    auto it = find(v.begin(), v.end(), 5);      // Cerca
    if (it != v.end())
        cout << "5 trovato a posizione " << (it - v.begin()) << "\n";

    // Lambda con find_if
    auto pari = find_if(v.begin(), v.end(), [](int n){ return n % 2 == 0; });
    cout << "Primo pari: " << *pari << "\n";

    int somma = 0;
    for_each(v.begin(), v.end(), [&somma](int n){ somma += n; });
    cout << "Somma: " << somma << "\n";

    v.erase(v.begin() + 2);  // Rimuove l'elemento a indice 2
    v.pop_back();             // Rimuove l'ultimo

    return 0;
}

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

int main() {
    // map: ordinato per chiave O(log n)
    map<string, int> punteggi;
    punteggi["Mario"]  = 95;
    punteggi["Giulia"] = 88;
    punteggi["Luca"]   = 72;
    punteggi["Anna"]   = 95;

    // Iterazione ordinata per chiave
    for (const auto &[nome, punteggio] : punteggi) {
        cout << nome << ": " << punteggio << "\n";
    }

    // Cerca
    if (punteggi.count("Mario"))
        cout << "Mario: " << punteggi.at("Mario") << "\n";

    // Rimuovi
    punteggi.erase("Luca");

    // unordered_map: non ordinato, O(1) medio con hash
    unordered_map<string, int> frequenza;
    string testo = "il gatto sul tetto il gatto mangia il topo";
    istringstream ss(testo);
    string parola;
    while (ss >> parola) frequenza[parola]++;

    cout << "\nFrequenza parole:\n";
    for (const auto &[w, f] : frequenza)
        cout << "  " << w << ": " << f << "\n";

    return 0;
}

#include <iostream>
#include <set>
#include <queue>
#include <stack>
#include <utility>   // pair
#include <tuple>
using namespace std;

int main() {
    // set: elementi unici, ordinati
    set<int> s = {5, 2, 8, 2, 1, 5, 9};
    for (int n : s) cout << n << " ";  // 1 2 5 8 9
    cout << "\n";

    s.insert(3);
    cout << "3 nel set? " << (s.count(3) ? "Sì" : "No") << "\n";

    // queue: FIFO
    queue<string> coda;
    coda.push("primo"); coda.push("secondo"); coda.push("terzo");
    while (!coda.empty()) {
        cout << coda.front() << " ";
        coda.pop();
    }
    cout << "\n";

    // stack: LIFO
    stack<int> pila;
    pila.push(1); pila.push(2); pila.push(3);
    while (!pila.empty()) { cout << pila.top() << " "; pila.pop(); }
    cout << "\n";

    // pair
    pair<string, int> p = {"ciao", 42};
    cout << p.first << " " << p.second << "\n";

    // tuple (C++11)
    auto t = make_tuple("Mario", 25, 3.14);
    cout << get<0>(t) << ", " << get<1>(t) << ", " << get<2>(t) << "\n";

    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>   // accumulate, reduce
#include <string>
using namespace std;

int main() {
    vector<int> v = {3,1,4,1,5,9,2,6,5,3,5};

    // sort con comparatore custom
    sort(v.begin(), v.end(), [](int a, int b){ return a > b; }); // Decrescente
    for (int n : v) cout << n << " ";
    cout << "\n";

    // unique: rimuove duplicati consecutivi (dopo sort)
    sort(v.begin(), v.end());
    auto ultimo = unique(v.begin(), v.end());
    v.erase(ultimo, v.end());
    cout << "Senza duplicati: ";
    for (int n : v) cout << n << " ";
    cout << "\n";

    // transform: applica funzione a ogni elemento
    vector<int> quadrati(v.size());
    transform(v.begin(), v.end(), quadrati.begin(),
              [](int n){ return n * n; });
    cout << "Quadrati: ";
    for (int n : quadrati) cout << n << " ";
    cout << "\n";

    // accumulate: somma (o operazione custom)
    int somma = accumulate(v.begin(), v.end(), 0);
    int prodotto = accumulate(v.begin(), v.end(), 1, [](int a, int b){ return a*b; });
    cout << "Somma: " << somma << ", Prodotto: " << prodotto << "\n";

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

    // any_of, all_of, none_of
    bool tutti_pos  = all_of(v.begin(), v.end(), [](int n){ return n>0; });
    bool qualche_gt5 = any_of(v.begin(), v.end(), [](int n){ return n>5; });
    cout << "Tutti > 0? " << tutti_pos << ", Qualcuno > 5? " << qualche_gt5 << "\n";

    // min_element, max_element
    auto minIt = min_element(v.begin(), v.end());
    auto maxIt = max_element(v.begin(), v.end());
    cout << "Min: " << *minIt << ", Max: " << *maxIt << "\n";

    return 0;
}

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

class Risorsa {
    string nome;
public:
    Risorsa(const string &n) : nome(n) { cout << "Creato: " << nome << "\n"; }
    ~Risorsa()                          { cout << "Distrutto: " << nome << "\n"; }
    void usa() const { cout << "Uso: " << nome << "\n"; }
};

int main() {
    // unique_ptr: UNICO proprietario, non copiabile
    {
        auto ptr = make_unique<Risorsa>("unico");
        ptr->usa();
        // Automaticamente distrutto alla fine del blocco
    }
    cout << "Dopo il blocco\n\n";

    // shared_ptr: proprietà CONDIVISA (reference counting)
    shared_ptr<Risorsa> sp1 = make_shared<Risorsa>("condiviso");
    cout << "Conteggio: " << sp1.use_count() << "\n";  // 1
    {
        shared_ptr<Risorsa> sp2 = sp1;  // Copia: conteggio aumenta
        cout << "Conteggio: " << sp1.use_count() << "\n";  // 2
        sp2->usa();
    }
    // sp2 distrutto → conteggio torna a 1
    cout << "Conteggio dopo blocco: " << sp1.use_count() << "\n";  // 1

    // Uso tipico in vector
    vector<unique_ptr<Risorsa>> risorse;
    risorse.push_back(make_unique<Risorsa>("A"));
    risorse.push_back(make_unique<Risorsa>("B"));
    risorse.push_back(make_unique<Risorsa>("C"));
    for (const auto &r : risorse) r->usa();
    // Tutti automaticamente distrutti alla fine del main

    return 0;
}