Esercizio - Ereditarietà, is-a e has-a, slicing (primo appello 2022-23, teoria)

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

// ---------- ereditarieta': Circle "is a" Shape ----------
class Shape {
public:
    Shape() = default;
    virtual ~Shape() = default;                           // distruttore virtuale
    Shape(const Shape&) = delete;                         // base di una gerarchia: copia vietata (contro lo slicing)
    Shape& operator=(const Shape&) = delete;

    virtual double area() const = 0;                      // virtuale pura: Shape e' astratta
    string name() const { return name_; }
protected:
    explicit Shape(string n) : name_{std::move(n)} {}     // visibile alle derivate
private:
    string name_ = "forma";
};

class Circle : public Shape {                             // ereditarieta' pubblica: Circle E' UNA Shape
public:
    explicit Circle(double r) : Shape("cerchio"), r_{r} {}
    double area() const override { return 3.14159 * r_ * r_; }
private:
    double r_;
};

// ---------- composizione: Car "has a" Wheel ----------
class Wheel {
public:
    explicit Wheel(int diametro) : diametro_{diametro} {}
    int diametro() const { return diametro_; }
private:
    int diametro_;
};

class Car {                                               // Car NON e' una Wheel: ne HA quattro
public:
    Car() : ruote_{Wheel(16), Wheel(16), Wheel(16), Wheel(16)} {}
    int n_ruote() const { return static_cast<int>(ruote_.size()); }
    int diametro_ruote() const { return ruote_[0].diametro(); }
private:
    vector<Wheel> ruote_;                                 // l'oggetto Wheel e' CONTENUTO dentro Car
};

// ---------- slicing ----------
class Base {
public:
    virtual ~Base() = default;
    virtual string chi() const { return "Base"; }
    int a = 1;
};
class Derivata : public Base {
public:
    string chi() const override { return "Derivata"; }
    int b = 2;                                            // dato membro in piu'
};

int main()
{
    unique_ptr<Shape> s = make_unique<Circle>(2.0);       // un puntatore alla base puo' puntare a una derivata
    cout << s->name() << ": area = " << s->area() << '\n';

    Car c;
    cout << "Car ha " << c.n_ruote() << " ruote da " << c.diametro_ruote() << " pollici\n";

    cout << "sizeof(Base) = " << sizeof(Base) << ", sizeof(Derivata) = " << sizeof(Derivata) << '\n';

    Derivata d;
    vector<Base> v;                                       // vector di OGGETTI Base
    v.push_back(d);                                       // SLICING: si copia solo la parte Base
    cout << "oggetto originale: " << d.chi() << ", copia nel vector<Base>: " << v[0].chi() << '\n';

    vector<unique_ptr<Base>> p;                           // soluzione: puntatori alla base
    p.push_back(make_unique<Derivata>());
    cout << "vector di puntatori: " << p[0]->chi() << '\n';

    const Base& r = d;                                    // soluzione: reference (nessuna copia)
    cout << "tramite reference: " << r.chi() << '\n';
    return 0;
}

cerchio: area = 12.5664
Car ha 4 ruote da 16 pollici
sizeof(Base) = 8, sizeof(Derivata) = 12
oggetto originale: Derivata, copia nel vector<Base>: Base
vector di puntatori: Derivata
tramite reference: Derivata