- Incapsulamento ed estensibilità dei Tipi
- Ereditarietà
- Polimorfismo
- L' Overload
- Funzioni Virtuali
- I Membri Statici di una classe
- Templates di Funzioni
- Templates delle Classi
- Classi Astratte
Polimorfismo
Il polimorfismo è una opportunità per le diverse classi di oggetti, relazionate attraverso l'ereditarietà, per rispondere in vari modi quando si chiama lo stesso elemento della funzione. Contribuisce a creare un meccanismo universale che descrive il comportamento non solo della classe base, ma anche delle classi discendenti.
Continuiamo a sviluppare una classe base CShape ,e definiamo un membro della funzione GetArea(), designato per calcolare l'area di una forma. In tutte le classi discendenti, prodotto per eredità dalla classe base, ri-definiamo questa funzione secondo le regole del calcolo dell'area di una forma particolare.
Per un quadrato (classe CSquare), l'area è calcolata attraverso i suoi lati, per un cerchio (classe CCircle), l'area si esprime attraverso il suo raggio, ecc. Siamo in grado di creare un array per memorizzare gli oggetti di tipo CShape, in cui entrambi gli oggetti di una classe base e quelli di tutte le classi discendenti possono essere memorizzati. Inoltre siamo in grado di chiamare la stessa funzione per ogni elemento della matrice.
Esempio:
//--- Base class
|
Ora, tutte le classi derivate hanno un membro di funzione getArea(), che restituisce un valore pari a zero. L'implementazione di questa funzione in ogni discendente varierà.
//--- La classe derivata Circle
|
Per la classe Square la dichiarazione è la stessa:
//--- La classe derivata Square
|
Per calcolare l'area del quadrato e del cerchio, abbiamo bisogno dei valori corrispondenti di m_radius e m_square_side, così abbiamo aggiunto la funzione setRadius e SetSide() nella dichiarazione della classe corrispondente.
Si presume che oggetti di tipo diverso (CCircle e CSquare) derivati da uno tipo base CShape sono utilizzati nel nostro programma. Il polimorfismo consente di creare un array di oggetti della classe base CShape, ma quando si dichiara questo array, questi oggetti sono ancora sconosciuti ed il loro tipo non è definito.
La decisione su quale tipo di oggetto sarà contenuto in ogni elemento della matrice sarà presa direttamente durante l'esecuzione del programma. Ciò comporta la creazione dinamica di oggetti di classi corrispondenti, e quindi la necessità di utilizzare puntatori agli oggetti invece degli oggetti.
Il nuovo operatore viene utilizzato per la creazione dinamica di oggetti. Ognuno di questi oggetti deve essere individualmente ed esplicitamente eliminato utilizzando l'operatore delete. Quindi noi dichiariamo un array di puntatori di tipo CShape, e creiamo un oggetto di un tipo adatto per ogni elemento (nome_nuovaClasse), come illustrato nello script di esempio seguente:
//+--------------------------------------------------------------------------------+
|
Si prega di notare che quando si elimina un oggetto utilizzando l'operatore delete, il tipo del suo puntatore deve essere controllato. Solo gli oggetti con il puntatore POINTER_DYNAMIC possono essere eliminati usando delete. Per i puntatori di altro tipo, verrà restituito un errore.
Ma oltre la ridefinizione delle funzioni durante la ereditarietà, il polimorfismo include anche l' implementazione di una e le stesse funzioni con diversi set di parametri all'interno di una classe. Ciò significa che la classe può avere funzioni diverse con lo stesso nome, ma con un diverso tipo e/o insieme di parametri. In questo caso, il polimorfismo è attuato mediante l'overload di funzione.
Vedi anche