Ereditarietà e Polimorfismo

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

class Veicolo {
protected:
    string targa;
    int    vmax;
public:
    Veicolo(const string &t, int v) : targa(t), vmax(v) {}
    virtual void descrizione() const {
        cout << "Veicolo " << targa << " (max " << vmax << " km/h)";
    }
    virtual ~Veicolo() {}
};

class Auto : public Veicolo {
    int porte;
public:
    Auto(const string &t, int v, int p) : Veicolo(t,v), porte(p) {}
    void descrizione() const override {
        Veicolo::descrizione();
        cout << " | Auto " << porte << " porte\n";
    }
};

class Moto : public Veicolo {
    string tipo;
public:
    Moto(const string &t, int v, const string &tipo) : Veicolo(t,v), tipo(tipo) {}
    void descrizione() const override {
        Veicolo::descrizione();
        cout << " | Moto " << tipo << "\n";
    }
};

class Camion : public Veicolo {
    double portata;
public:
    Camion(const string &t, int v, double p) : Veicolo(t,v), portata(p) {}
    void descrizione() const override {
        Veicolo::descrizione();
        cout << " | Camion " << portata << "t\n";
    }
};

int main() {
    vector<unique_ptr<Veicolo>> parco;
    parco.push_back(make_unique<Auto>("AB123CD", 180, 5));
    parco.push_back(make_unique<Moto>("XZ789AB", 220, "sportiva"));
    parco.push_back(make_unique<Camion>("CA001ZZ", 120, 18.5));

    for (const auto &v : parco) v->descrizione();
}

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

class Notificatore {
public:
    virtual void invia(const string &msg) const = 0;
    virtual string tipo() const = 0;
    virtual ~Notificatore() {}
};

class EmailNotificatore : public Notificatore {
    string email;
public:
    EmailNotificatore(const string &e) : email(e) {}
    void invia(const string &msg) const override {
        cout << "[EMAIL → " << email << "] " << msg << "\n";
    }
    string tipo() const override { return "Email"; }
};

class SMSNotificatore : public Notificatore {
    string numero;
public:
    SMSNotificatore(const string &n) : numero(n) {}
    void invia(const string &msg) const override {
        cout << "[SMS → " << numero << "] " << msg.substr(0, 160) << "\n";
    }
    string tipo() const override { return "SMS"; }
};

class PushNotificatore : public Notificatore {
    string device;
public:
    PushNotificatore(const string &d) : device(d) {}
    void invia(const string &msg) const override {
        cout << "[PUSH → " << device << "] 🔔 " << msg << "\n";
    }
    string tipo() const override { return "Push"; }
};

void notifica_tutti(const vector<Notificatore*> &lista, const string &msg) {
    cout << "\nInvio a " << lista.size() << " destinatari:\n";
    for (const auto *n : lista) n->invia(msg);
}

int main() {
    EmailNotificatore email("mario@example.com");
    SMSNotificatore   sms("+39 333 1234567");
    PushNotificatore  push("iPhone-Mario");

    vector<Notificatore*> lista = {&email, &sms, &push};
    notifica_tutti(lista, "Il tuo ordine è stato spedito!");
}

#include <iostream>
#include <memory>
#include <cstdlib>
#include <ctime>
using namespace std;

class Personaggio {
protected:
    string nome;
    int hp, maxHp, attacco, difesa;

public:
    Personaggio(const string &n, int hp, int atk, int def)
        : nome(n), hp(hp), maxHp(hp), attacco(atk), difesa(def) {}

    virtual void abilita_speciale(Personaggio &nemico) = 0;
    virtual string classe() const = 0;
    virtual ~Personaggio() {}

    void subisci_danno(int danno) {
        int reale = max(0, danno - difesa);
        hp = max(0, hp - reale);
        cout << "  " << nome << " subisce " << reale << " danni (HP: " << hp << "/" << maxHp << ")\n";
    }

    bool isVivo() const { return hp > 0; }
    string getNome() const { return nome; }

    void attacca(Personaggio &nemico) {
        cout << nome << " attacca " << nemico.nome << " per " << attacco << "!\n";
        nemico.subisci_danno(attacco);
    }

    void stampa() const {
        cout << "[" << classe() << "] " << nome
             << " HP:" << hp << "/" << maxHp
             << " ATK:" << attacco << " DEF:" << difesa << "\n";
    }
};

class Guerriero : public Personaggio {
public:
    Guerriero(const string &n) : Personaggio(n, 120, 18, 8) {}
    string classe() const override { return "Guerriero"; }
    void abilita_speciale(Personaggio &nemico) override {
        cout << nome << " usa COLPO DOPPIO!\n";
        nemico.subisci_danno(attacco);
        nemico.subisci_danno(attacco);
    }
};

class Mago : public Personaggio {
public:
    Mago(const string &n) : Personaggio(n, 80, 28, 3) {}
    string classe() const override { return "Mago"; }
    void abilita_speciale(Personaggio &nemico) override {
        int magia = attacco * 2;
        cout << nome << " lancia PALLA DI FUOCO per " << magia << "!\n";
        nemico.subisci_danno(magia);
    }
};

class Ladro : public Personaggio {
public:
    Ladro(const string &n) : Personaggio(n, 90, 22, 5) {}
    string classe() const override { return "Ladro"; }
    void abilita_speciale(Personaggio &nemico) override {
        if (rand() % 2) {
            cout << nome << " CRITICO! Danno x3!\n";
            nemico.subisci_danno(attacco * 3);
        } else {
            cout << nome << " manca il colpo critico!\n";
        }
    }
};

int main() {
    srand(time(0));

    unique_ptr<Personaggio> p1 = make_unique<Guerriero>("Arthas");
    unique_ptr<Personaggio> p2 = make_unique<Mago>("Merlin");

    cout << "=== COMBATTIMENTO ===\n";
    p1->stampa(); p2->stampa();

    int turno = 1;
    while (p1->isVivo() && p2->isVivo()) {
        cout << "\n--- Turno " << turno++ << " ---\n";
        if (turno % 3 == 0) { p1->abilita_speciale(*p2); }
        else p1->attacca(*p2);
        if (!p2->isVivo()) break;
        if (turno % 4 == 0) p2->abilita_speciale(*p1);
        else p2->attacca(*p1);
    }

    cout << "\n=== FINE ===\n";
    cout << (p1->isVivo() ? p1->getNome() : p2->getNome()) << " vince!\n";
}