Esercizio - Polimorfismo statico e dinamico, bounded e unbounded (secondo appello 2022-23, teoria)

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

// Polimorfismo DINAMICO: ereditarieta' + funzioni virtuali, binding a run-time.
class Shape {
public:
    virtual double area() const = 0;                 // virtuale pura: interfaccia comune, classe astratta
    virtual const char* name() const = 0;
    virtual ~Shape() = default;                      // distruttore virtuale: si cancella via puntatore alla base
    Shape() = default;
    Shape(const Shape&) = delete;                    // niente copia in una gerarchia (slicing)
    Shape& operator=(const Shape&) = delete;
};

class Circle : public Shape {
public:
    explicit Circle(double r) : r_{r} {}
    double area() const override { return 3.14159 * r_ * r_; }
    const char* name() const override { return "Circle"; }
private:
    double r_;
};

class Rectangle : public Shape {
public:
    Rectangle(double w, double h) : w_{w}, h_{h} {}
    double area() const override { return w_ * h_; }
    const char* name() const override { return "Rectangle"; }
private:
    double w_, h_;
};

// UNA sola funzione serve per tutte le forme: la chiamata area() e' risolta a run-time
void stampa(const Shape& s)
{
    cout << s.name() << ": area = " << s.area() << '\n';
}

int main()
{
    vector<unique_ptr<Shape>> forme;                 // collezione eterogenea tramite puntatori alla base
    forme.push_back(make_unique<Circle>(1.0));
    forme.push_back(make_unique<Rectangle>(2.0, 3.0));
    for (const auto& f : forme) stampa(*f);          // la scelta di Circle::area o Rectangle::area avviene qui
    // Shape s;                                      // errore: Shape e' astratta
    return 0;
}

Circle: area = 3.14159
Rectangle: area = 6

#include <iostream>
using namespace std;

// Polimorfismo STATICO: template, binding a compile-time. Nessuna classe base comune.
class Circle {
public:
    explicit Circle(double r) : r_{r} {}
    double area() const { return 3.14159 * r_ * r_; }
    const char* name() const { return "Circle"; }
private:
    double r_;
};

class Rectangle {
public:
    Rectangle(double w, double h) : w_{w}, h_{h} {}
    double area() const { return w_ * h_; }
    const char* name() const { return "Rectangle"; }
private:
    double w_, h_;
};

// Esistono tante stampa<T> quante sono le forme usate: stampa<Circle>, stampa<Rectangle>, ...
template <typename Shape>
void stampa(const Shape& s)
{
    cout << s.name() << ": area = " << s.area() << '\n';    // basta che Shape abbia name() e area()
}

int main()
{
    Circle c {1.0};
    Rectangle r {2.0, 3.0};
    stampa(c);                                       // istanzia stampa<Circle>
    stampa(r);                                       // istanzia stampa<Rectangle>
    // stampa(42);                                   // errore di compilazione: int non ha area()
    return 0;
}

Circle: area = 3.14159
Rectangle: area = 6

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

// Due classi SENZA alcuna parentela: non c'e' una classe base, ma hanno la stessa sintassi (speak()).
struct Cane  { string speak() const { return "bau"; } };
struct Robot { string speak() const { return "beep"; } int batteria = 90; };   // ha anche altro

// Polimorfismo statico UNBOUNDED: non esiste un'interfaccia dichiarata, basta che T abbia speak()
template <typename T>
void ascolta(const T& x)
{
    cout << x.speak() << '\n';
}

int main()
{
    ascolta(Cane{});            // istanza ascolta<Cane>
    ascolta(Robot{});           // istanza ascolta<Robot>
    return 0;
}

bau
beep