Classi Astratte in C++

Le classi astratte sono un concetto importante in C++ che permette di definire interfacce e fornire una struttura comune per le classi derivate. Una classe astratta non può essere istanziata direttamente, ma può essere utilizzata come base per altre classi derivate che implementano i suoi metodi astratti. In questo articolo, esploreremo in dettaglio cosa sono le classi astratte, come definirle e perché sono utili.

Cos’è una Classe Astratta

Una classe astratta è una classe che contiene almeno un metodo astratto (anche chiamato metodo puro) e non può essere istanziata direttamente. Un metodo astratto è un metodo che non ha implementazione nella classe astratta, ma deve essere implementato nelle classi derivate. Le classi astratte forniscono una struttura comune e un’interfaccia per le classi derivate.

Definire una Classe Astratta

Per definire una classe astratta in C++, utilizziamo la parola chiave class seguita dal nome della classe e da uno o più metodi astratti dichiarati con = 0;.

class ClasseAstratta {
public:
    virtual void metodoAstratto() = 0;
};

In questo esempio, metodoAstratto è un metodo astratto dichiarato con = 0;.

Utilizzare Classi Derivate

Le classi derivate devono implementare tutti i metodi astratti ereditati dalla classe astratta. Solo allora possono essere istanziate.

class ClasseConcreta : public ClasseAstratta {
public:
    void metodoAstratto() override {
        // Implementazione del metodo astratto
    }
};

In questo esempio, ClasseConcreta eredita da ClasseAstratta e implementa il metodo astratto metodoAstratto.

Vantaggi delle Classi Astratte

Le classi astratte offrono diversi vantaggi:

• Definizione di Interfacce: Le classi astratte consentono di definire interfacce comuni per un gruppo di classi derivate. Questo promuove la coerenza e il riuso del codice.

• Forza l’Implementazione: Le classi astratte costringono le classi derivate a implementare metodi specifici, garantendo che tali metodi siano disponibili in tutte le classi derivate.

• Polimorfismo: Le classi astratte possono essere utilizzate con il polimorfismo, consentendo di trattare oggetti di classi derivate come oggetti della classe astratta.

Esempio di Utilizzo delle Classi Astratte

#include <iostream>

class Forma {
public:
    virtual double calcolaArea() const = 0;
};

class Rettangolo : public Forma {
private:
    double lunghezza;
    double larghezza;

public:
    Rettangolo(double l, double w) : lunghezza(l), larghezza(w) {}

    double calcolaArea() const override {
        return lunghezza * larghezza;
    }
};

class Cerchio : public Forma {
private:
    double raggio;

public:
    Cerchio(double r) : raggio(r) {}

    double calcolaArea() const override {
        return 3.14159265 * raggio * raggio;
    }
};

int main() {
    Rettangolo rett(5.0, 3.0);
    Cerchio cerchio(2.0);

    Forma* forma1 = &rett;
    Forma* forma2 = &cerchio;

    std::cout << "Area del rettangolo: " << forma1->calcolaArea() << std::endl;
    std::cout << "Area del cerchio: " << forma2->calcolaArea() << std::endl;

    return 0;
}

In questo esempio, Forma è una classe astratta che definisce un metodo astratto calcolaArea(). Le classi derivate Rettangolo e Cerchio implementano questo metodo astratto. Grazie al polimorfismo, è possibile trattare oggetti di queste classi derivate come oggetti di tipo Forma e chiamare il metodo calcolaArea() in modo coerente.

Conclusioni

Le classi astratte sono un concetto fondamentale nella programmazione orientata agli oggetti in C++. Consent

ono di definire interfacce comuni e strutture di base per le classi derivate, promuovendo il riuso del codice e garantendo l’implementazione di metodi specifici. Utilizzate con attenzione, le classi astratte migliorano la progettazione e la manutenzione del codice.