C++ Polimorfismo con esempio

Sebbene abbiamo una funzione, questa si comporta diversamente in circostanze diverse. La funzione ha molte forme; quindi, abbiamo raggiunto il polimorfismo.

Tipi di polimorfismo

C++ supporta due tipi di polimorfismo:

• Polimorfismo in fase di compilazione e
• Polimorfismo di runtime.

Polimorfismo in fase di compilazione

Si richiamano le funzioni sovraccaricate facendo corrispondere il numero e il tipo di argomenti. Le informazioni sono presenti durante la compilazione. Ciò significa che C++ il compilatore selezionerà la funzione giusta in fase di compilazione.

Il polimorfismo in fase di compilazione si ottiene tramite l'overloading delle funzioni e l'overloading degli operatori.

Sovraccarico delle funzioni

Il sovraccarico delle funzioni si verifica quando abbiamo molte funzioni con nomi simili ma argomenti diversi. Gli argomenti possono differire in termini di numero o tipo.

esempio 1

#include <iostream> 
using namespace std;

void test(int i) {
	cout << " The int is " << i << endl;
}
void test(double  f) {
	cout << " The float is " << f << endl;
}
void test(char const *ch) {
	cout << " The char* is " << ch << endl;
}

int main() {
	test(5);
	test(5.5);
	test("five");
	return 0;
}

Produzione:

Ecco uno screenshot del codice:

Spiegazione del codice:

1. Includi il file di intestazione iostream nel nostro codice. Potremo utilizzare le sue funzioni.
2. Includi lo spazio dei nomi std nel nostro codice. Potremo utilizzare le sue classi senza chiamarlo.
3. Crea una funzione denominata test che accetta un parametro intero i. Il { segna l'inizio del corpo del test funzionale.
4. Istruzione da eseguire se viene invocato/chiamato il test funzionale di cui sopra.
5. Fine del corpo del test funzionale di cui sopra.
6. Crea una funzione denominata test che accetta un parametro float f. Il { segna l'inizio del corpo del test funzionale.
7. Istruzione da eseguire se viene invocato/chiamato il test funzionale di cui sopra.
8. Fine del corpo del test funzionale di cui sopra.
9. Crea una funzione denominata test che accetta un parametro di carattere ch. Il { segna l'inizio del corpo del test funzionale.
10. Istruzione da eseguire se viene invocato/chiamato il test funzionale di cui sopra.
11. Fine del corpo del test funzionale di cui sopra.
12. Chiama la funzione main(). Il { segna l'inizio del corpo della funzione.
13. Chiama la funzione test e passale 5 come valore dell'argomento. Ciò richiama la funzione di test che accetta un argomento intero, ovvero la prima funzione di test.
14. Chiama la funzione test e passale 5.5 come valore dell'argomento. Ciò invocherà la funzione di test che accetta un argomento float, ovvero la seconda funzione di test.
15. Chiama la funzione test e passale cinque come valore dell'argomento. Ciò invocherà la funzione di test che accetta un argomento di tipo carattere, ovvero la terza funzione di test.
16. Il programma deve restituire un valore se viene eseguito correttamente.
17. La fine del corpo della funzione main().

Abbiamo tre funzioni con lo stesso nome ma diversi tipi di argomenti. Abbiamo raggiunto il polimorfismo.

Operasovraccarico

In Operato Overloading, definiamo un nuovo significato per a C++ operatore. Cambia anche il modo in cui funziona l'operatore. Ad esempio, possiamo definire l'operatore + per concatenare due stringhe. Lo conosciamo come operatore di addizione per aggiungere valori numerici. Dopo la nostra definizione, quando viene inserito tra interi, li aggiungerà. Quando viene inserito tra stringhe, le concatenerà.

esempio 2

#include<iostream> 
using namespace std;

class ComplexNum {
private:
	int real, over;
public:
	ComplexNum(int rl = 0, int ov = 0) {
		real = rl;   
		over = ov; 
	}

	ComplexNum operator + (ComplexNum const &obj) {
		ComplexNum result;
		result.real = real + obj.real;
		result.over = over + obj.over;
		return result;
	}
	void print() { 
		cout << real << " + i" << over << endl; 
	}
};
int main()
{
	ComplexNum c1(10, 2), c2(3, 7);
	ComplexNum c3 = c1+c2;
	c3.print();
}

Produzione:

Ecco uno screenshot del codice:

Spiegazione del codice:

1. Includi il file header iostream nel nostro programma per poter utilizzare le sue funzioni.
2. Includi lo spazio dei nomi std nel nostro programma per poter utilizzare le sue classi senza chiamarlo.
3. Crea una classe denominata ComplexNum. { segna l'inizio del corpo della classe.
4. Utilizza il modificatore di accesso privato per contrassegnare le variabili come private, il che significa che è possibile accedervi solo dall'interno della classe.
5. Definire due variabili intere, reale e superiore.
6. Utilizza il modificatore di accesso pubblico per contrassegnare il costruttore come pubblico, il che significa che sarà accessibile anche dall'esterno classe.
7. Creare il costruttore della classe e inizializzare le variabili.
8. Inizializza il valore della variabile real.
9. Inizializza il valore della variabile sopra.
10. Fine del corpo del costruttore.
11. Dobbiamo sovrascrivere il significato dell'operatore +.
12. Crea il risultato del tipo di dati ComplexNum.
13. Usa l'operatore + con numeri complessi. Questa riga aggiungerà la parte reale di un numero alla parte reale di un altro numero.
14. Usa l'operatore + con numeri complessi. Questa riga aggiungerà la parte immaginaria di un numero alla parte immaginaria di un altro numero.
15. Il programma restituirà il valore della variabile result dopo l'esecuzione riuscita.
16. Fine della definizione del nuovo significato dell'operatore +, cioè sovraccarico.
17. Chiama il metodo print().
18. Stampa il nuovo numero complesso dopo l'addizione sulla console.
19. Fine del corpo della funzione print().
20. Fine del corpo della classe ComplexNum.
21. Chiama la funzione main().
22. Passare i valori delle parti reali e complesse da sommare. La prima parte di c1 verrà sommata alla prima parte di c2, ovvero 10+3. La seconda parte di c1 verrà sommata alla seconda parte di c, ovvero 2+7.
23. Eseguire un'operazione utilizzando l'operatore sovraccaricato + e memorizzando il risultato nella variabile c3.
24. Stampa il valore della variabile c3 sulla console.
25. Fine del corpo della funzione main().

Polimorfismo di runtime

Ciò accade quando il metodo di un oggetto viene invocato/chiamato durante il runtime anziché durante la compilazione. Il polimorfismo di runtime si ottiene tramite l'override delle funzioni. La funzione da chiamare/invocare viene stabilita in fase di runtime.

Sovrascrittura delle funzioni

L'override della funzione si verifica quando a una funzione della classe base viene assegnata una nuova definizione in una classe derivata. A quel punto, possiamo dire che la funzione di base è stata sovrascritta.

Per esempio:

#include <iostream>
using namespace std;
class Mammal {

public:
	void eat() {

		cout << "Mammals eat...";
	}

};

class Cow: public Mammal {

public:
	void eat() {

		cout << "Cows eat grass...";
	}
};
int main(void) {

	Cow c = Cow();

	c.eat();

	return 0;

}

Produzione:

Ecco uno screenshot del codice:

Spiegazione del codice:

1. Importa il file header iostream nel nostro programma per utilizzare le sue funzioni.
2. Includi lo spazio dei nomi std nel nostro programma per poter utilizzare le sue classi senza chiamarlo.
3. Crea una classe chiamata Mammifero. Il { segna l'inizio del corpo della classe.
4. Utilizza il modificatore di accesso pubblico per impostare la funzione che stiamo per creare come accessibile pubblicamente. Sarà accessibile dall'esterno di questa classe.
5. Crea una funzione pubblica denominata mangia. Il { segna l'inizio del corpo della funzione.
6. Stampa l'istruzione aggiunta alla funzione cout quando viene invocata la funzione eat().
7. La fine del corpo della funzione eat().
8. Fine del corpo della classe Mammifero.
9. Crea una classe denominata Mucca che eredita la classe Mammifero. La mucca è la classe derivata, mentre il mammifero è la classe base. Il { segna l'inizio di questa lezione.
10. Utilizza il modificatore di accesso pubblico per contrassegnare la funzione che stiamo per creare come accessibile pubblicamente. Sarà accessibile dall'esterno di questa classe.
11. Sostituisci la funzione eat() definita nella classe base. Il { segna l'inizio del corpo della funzione.
12. L'istruzione da stampare sulla console quando viene richiamata questa funzione.
13. Fine del corpo della funzione eat().
14. Fine del corpo della classe Mucca.
15. Chiama la funzione main(). Il { segna l'inizio del corpo di questa funzione.
16. Creare un'istanza della classe Cow e darle il nome c.
17. Chiama la funzione eat() definita nella classe Cow.
18. Il programma deve restituire un valore in caso di completamento positivo.
19. Fine della funzione main().

C++ Funzione virtuale

Una funzione virtuale è un altro modo di implementare il polimorfismo in fase di esecuzione C++. È una funzione speciale definita in una classe base e ridefinita nella classe derivata. Per dichiarare una funzione virtuale, dovresti usare la parola chiave virtual. La parola chiave dovrebbe precedere la dichiarazione della funzione nella classe base.

Se una classe di funzione virtuale viene ereditata, la classe virtuale ridefinisce la funzione virtuale per adattarla alle proprie esigenze. Per esempio:

#include <iostream>  
using namespace std;
class ClassA {
		public:
		virtual void show() {
			cout << "The show() function in base class invoked..." << endl;
		}
	};
	class ClassB :public ClassA {
	public:
		void show() 	{
			cout << "The show() function in derived class invoked...";
		}
	};
	int main() {
		ClassA* a;   
		ClassB b;
		a = &b;
		a->show();      
	}

Produzione:

Ecco uno screenshot del codice:

Spiegazione del codice:

1. Includere il file di intestazione iostream nel codice per utilizzare le sue funzioni.
2. Includi lo spazio dei nomi std nel nostro codice per utilizzare le sue classi senza chiamarlo.
3. Crea una classe denominata ClassA.
4. Utilizza il modificatore di accesso pubblico per contrassegnare un membro della classe come accessibile pubblicamente.
5. Crea una funzione virtuale denominata show(). Sarà una funzione pubblica.
6. Il testo da stampare quando viene invocato show(). La fine è a C++ parola chiave, che significa riga di fine. Sposta il cursore del mouse sulla riga successiva.
7. Fine del corpo della funzione virtuale show().
8. Fine del corpo della classe ClassA.
9. Creazione di una nuova classe denominata ClassB che eredita la classe ClassA. ClassA diventa la classe base mentre ClassB diventa la classe derivata.
10. Utilizza il modificatore di accesso pubblico per contrassegnare un membro della classe come accessibile pubblicamente.
11. Ridefinire la funzione virtuale show() derivata nella classe base.
12. Il testo da stampare sulla console quando viene richiamata la funzione show() definita nella classe derivata.
13. Fine del corpo della funzione show().
14. Fine del corpo della classe derivata, ClassB.
15. Chiama la funzione main(). La logica del programma dovrebbe essere aggiunta all'interno del suo corpo.
16. Creare una variabile puntatore denominata a. Punta alla classe denominata ClassA.
17. Crea un'istanza della classe denominata ClassB. All'istanza viene assegnato il nome b.
18. Assegnare i valori memorizzati nell'indirizzo b nella variabile a.
19. Richiama la funzione show() definita nella classe derivata. È stata implementata la rilegatura tardiva.
20. Fine del corpo della funzione main().

Polimorfismo in fase di compilazione vs. Polimorfismo in fase di esecuzione

Ecco le principali differenze tra i due:

Polimorfismo in fase di compilazione	Polimorfismo run-time
Si chiama anche polimorfismo di legame precoce o statico	È chiamato anche legame tardivo/dinamico o polimorfismo dinamico
Il metodo viene chiamato/invocato durante la fase di compilazione	Il metodo viene chiamato/invocato durante il runtime
Implementato tramite l'overload delle funzioni e l'overload degli operatori	Implementato tramite override del metodo e funzioni virtuali
Esempio, sovraccarico del metodo. Molti metodi possono avere nomi simili ma numero o tipi di argomenti diversi	Esempio, override del metodo. Molti metodi possono avere un nome simile e lo stesso prototipo.
Esecuzione più rapida poiché il rilevamento dei metodi viene eseguito durante la fase di compilazione	Esecuzione più lenta poiché il rilevamento dei metodi viene eseguito durante il runtime.
Less viene fornita flessibilità per la risoluzione dei problemi poiché tutto è noto durante la fase di compilazione.	Viene garantita una grande flessibilità nella risoluzione di problemi complessi poiché i metodi vengono scoperti durante l'esecuzione.

Sintesi

• Polimorfismo significa avere molte forme.
• Si verifica quando esiste una gerarchia di classi correlate tramite ereditarietà.
• Con il polimorfismo una funzione può comportarsi diversamente in base all'oggetto che la invoca/chiama.
• Nel polimorfismo in fase di compilazione, la funzione da invocare viene stabilita durante la fase di compilazione.
• Nel polimorfismo runtime, la funzione da invocare viene stabilita durante il runtime.
• Il polimorfismo in fase di compilazione viene determinato tramite l'overload delle funzioni e l'overload degli operatori.
• Nell'overloading delle funzioni, esistono molte funzioni con nomi simili ma argomenti diversi.
• I parametri possono differire per numero o tipologia.
• Nell'overloading degli operatori viene definito un nuovo significato per C++ Operatori.
• Il polimorfismo di runtime si ottiene tramite l'override delle funzioni.
• Nell'override di una funzione, una classe derivata fornisce una nuova definizione a una funzione definita nella classe base.