Polimorfismo in esempi di C ++

Il polimorfismo, che implica "varie forme", si verifica quando più classi sono collegate tramite ereditarietà. In vari contesti, la stessa cosa (metodo o operatore) agisce in modo diverso. Possiamo ereditare le proprietà e le funzioni di qualche altra classe tramite eredità. Il polimorfismo utilizza queste tecniche per una varietà di scopi. Questo ci consente di svolgere una particolare attività in vari modi. Pertanto, all'interno di questo articolo, discuteremo di esempi di polimorfismo in C ++ usando alcuni esempi all'interno di Ubuntu 20.04. Lo abbiamo avviato con la creazione e l'avvio di un nuovo file C ++ nella console terminale.

Polimorfismo $ touch.cc
$ nano polimorfismo.cc

Esempio 01: sovraccarico di funzioni

Quando i loro argomenti sono unici, è possibile utilizzare due funzioni primarie con lo stesso titolo in C++. Vari metodi sono chiamati in base alla quantità e al tipo di parametri e questo concetto è noto come sovraccarico di funzioni. Abbiamo iniziato il nostro primo esempio con lo spazio dei nomi "std" standard e keeder input-output "iostream". Sono definite tre nomi definiti dall'utente, ciascuno contenente una singola istruzione cout. La prima funzione contiene un parametro di tipo intero, la seconda contiene il parametro a doppio tipo e l'ultimo contiene due parametri a doppio tipo. Le prime due funzioni "Val" ottengono semplicemente valore dal metodo principale () e lo visualizzano sulla shell tramite l'istruzione Cout. Il terzo sta ottenendo due valori a doppio tipo dal main () e mostra la somma di entrambi i valori sulla shell con l'aiuto della clausola Cout. La funzione principale () è semplicemente chiamare tre metodi dello stesso nome uno dopo l'altro passando valori diversi.

#includere
Utilizzo dello spazio dei nomi std;
int val (int n1)
cout <<"Integer: "<< n1 <
doppio val (doppio n1)
cout <<"Double: "<< n1 <
doppio val (doppio N1, doppio N2)
cout << "Sum: "<< n1+n2<
int main ()
Val (10);
Val (9.25);
Val (4.1, 8.23);
restituzione 0;

La compilazione di questo codice C ++ ha esito positivo utilizzando il compilatore G ++ sulla shell.

polimorfismo $ g ++.cc

Dopo aver eseguito il codice, abbiamo i valori visualizzati sulla console di seguito.

$ ./UN.fuori

Esempio 02: sovraccarico dell'operatore

Il sovraccarico dell'operatore è simile al sovraccarico del metodo perché utilizza lo stesso segno ma vari operandi per metodi di operatore distinti. Quindi, abbiamo iniziato questo esempio dichiarando una nuova classe "A" dopo lo spazio dei nomi e la biblioteca. La classe A contiene un membro dei dati privati ​​del tipo intero "V" e una funzione di costruttore A () utilizzata per inizializzare la variabile "V" con un valore di 5. Ecco che arriva la funzione dell'operatore per incrementare il valore di "V" di 3. Come mostra il nome, l'operatore "+" è stato sovraccarico qui. La funzione show () è qui per mostrare il valore incrementato di una variabile “V."Alla creazione di un oggetto, verrà eseguito il costruttore a (). L'oggetto è stato usato per chiamare la funzione dell'operatore "++". L'OBJ viene nuovamente utilizzato per chiamare la funzione show () per visualizzare il valore incrementato.

#includere
Utilizzo dello spazio dei nomi std;
classe A
privato:
in tv;
pubblico:
A (): v (5)
void operatore ++ ()
v = v + 3;

void show ()
cout << "Value after increment: " << v << endl;

;
int main ()
Un obj;
++obj;
obj.spettacolo();
restituzione 0;

Dopo la compilazione, non abbiamo errori. Il valore incrementato della variabile "V" è stato visualizzato sulla nostra schermata terminale al momento dell'esecuzione di questo codice.

polimorfismo $ g ++.cc
$ ./UN.fuori

Esempio 03: Prevalente della funzione

La classe base e le sue sottoclassi discendenti possono avere lo stesso nome metodi. Quando utilizziamo un'istanza dalla sottoclasse per invocare il metodo, la funzione della classe estesa viene eseguita anziché la classe principale. Di conseguenza, le varie funzioni verranno eseguite a seconda dell'oggetto invocando il metodo. In C ++, questo è indicato come metodo prevalente. Quindi, abbiamo inizializzato tre classi nel codice. La classe A è la classe genitore di entrambe le classi di figli B e C. Tutte le classi hanno lo stesso nome funzione, "show ()", visualizzando le sue specifiche tramite l'istruzione cout. Il metodo principale () ha creato 3 oggetti per 3 classi per chiamare le rispettive funzioni.

#includere
Utilizzo dello spazio dei nomi std;
classe A
pubblico:
void show ()
cout << "Base class A… " << endl;
;
Classe B: pubblico a
pubblico:
void show ()
cout << "Derived class B… " << endl;
;
Classe C: pubblico a
pubblico:
void show ()
cout << "Derived class C… " << endl;
;
int main ()
A o1;
O1.spettacolo();
B o2;
o2.spettacolo();
C o3;
O3.spettacolo();
restituzione 0;

Abbiamo ottenuto tutti i metodi eseguiti da tutte le classi all'esecuzione di questo file di codice.

Esempio 04: funzioni virtuali

Se utilizziamo un "puntatore" di riferimento della classe base per fare riferimento a un oggetto di classe derivata, potremmo non essere nemmeno in grado di eludere i metodi in C++. In queste circostanze, l'uso di metodi virtuali nella classe genitore assicura che il metodo possa essere ignorato. Quindi, abbiamo creato una Classe A genitore con il suo bambino di classe B. Entrambe le classi hanno le funzioni dello stesso nome, ma la funzione Classe Parente contiene la parola chiave "virtuale."In Main (), l'oggetto della classe B" B "è stato usato come riferimento all'oggetto puntatore della classe genitore" A "A" A."

#includere
Utilizzo dello spazio dei nomi std;
classe A
pubblico:
virtual void show ()
cout << "Base class A… " << endl;

;
Classe B: pubblico a
pubblico:
void show ()
cout << "Derived class B… " restituzione 0;

Al momento dell'esecuzione di questo codice, il metodo della classe derivata è stato eseguito utilizzando la parola chiave virtuale nella funzione dello stesso nome definito dall'utente della classe principale.

polimorfismo $ g ++.cc
$ ./UN.outg

Conclusione:

Si trattava di usare il polimorfismo in C ++ usando alcuni dei suoi concetti di base. Per renderlo liscio, abbiamo coperto il sovraccarico di funzioni, il sovraccarico delle funzioni, il sovraccarico dell'operatore e il concetto di funzione virtuale. Speriamo nel miglior feedback per questo lavoro.