Phenquestions
In questo articolo, discuteremo il concetto di ereditarietà nella programmazione C++. Spiegheremo il concetto della funzione friend in C++ con esempi funzionanti.
Perché l'ereditarietà??
L'ereditarietà consente di creare una nuova classe o una classe derivata da un'altra classe o classe base. La classe derivata o la classe figlia avrà tutte le caratteristiche della classe genitore o della classe base. Possiamo riutilizzare il codice con l'aiuto dell'ereditarietà.
Tipo di eredità
Esistono diversi tipi di ereditarietà:
- Ereditarietà semplice/singola
- Eredità gerarchicaarchi
- Ereditarietà multilivello
- Eredità multipla
In questo articolo, prenderemo in considerazione solo l'ereditarietà semplice/singola.
Esempio 1:
Ora, esaminiamo un programma di esempio per comprendere il concetto di ereditarietà in C++. Abbiamo definito una classe base e ne abbiamo derivato un'altra classe. Pertanto, la classe derivata avrà le caratteristiche (membri e funzioni) della classe base.
#includereusando lo spazio dei nomi std;
class Base_Class
pubblico:
int io;
display vuoto()
cout << "Display of Base Class " << i << endl;
;
class Classe_derivata:Classe_base pubblica
pubblico:
spettacolo vuoto()
cout << "Show of Derived Class" << endl;
;
intero principale()
Derivato_Classe dc;
dc.io = 100;
dc.Schermo();
dc.mostrare();
restituisce 0;
Esempio 2:
Questo è un altro esempio di ereditarietà in C++. In questo esempio, vedremo come vengono chiamati i costruttori quando viene creato un oggetto di classe derivata.
Come puoi vedere di seguito, abbiamo definito due costruttori di classi base e tre costruttori di classi derivate. È possibile notare chiaramente dall'output seguente che il costruttore della classe base viene chiamato prima che venga chiamato il costruttore della classe derivata.
#includere#includere
usando lo spazio dei nomi std;
class Base_Class
pubblico:
Classe_base()
cout << "Base_Class - No Parameters" << endl;
Base_Class(int x)
cout << "Base_Class - Parameters : " << x << endl;
;
class Classe_derivata:Classe_base pubblica
pubblico:
Classe_derivato()
cout << "Derived_Class - No Parameters" << endl;
Derived_Class(int y)
cout << "Derived_Class - Parameters : " << y << endl;
Derived_Class(int x,int y):Base_Class(x)
cout << "Param of Derived_Class : " << y << endl;
;
intero principale()
Derivato_Classe d(7,19);
Esempio 3:
In questo esempio, vedremo come possono essere usati gli oggetti di classe derivati.
Come puoi vedere, sono definite due classi: Rectangle_Class e Cube_Class. La Rectangle_Class è la classe base da cui la classe derivata, i.e., Cube_Class è derivato. Pertanto, ereditiamo le funzionalità da Rectangle_Class a Cube_Class.
Inoltre, puoi notare che stiamo ereditando Cube_Class con il controllo dell'accesso pubblico. Ciò significa che la classe derivata può accedere a tutti i membri non privati della classe base.
Abbiamo dichiarato un oggetto della classe derivata e quindi chiamiamo i metodi dalla classe base, i.e., setLength() e setBreadth().
#includereusando lo spazio dei nomi std;
class Rectangle_Class
privato:
lunghezza intera;
larghezza interna;
pubblico:
Rectangle_Class();
Rectangle_Class(int l,int b);
Rectangle_Class(Rectangle_Class &r);
int getLength()
lunghezza di ritorno;
int getBreadth()
larghezza di ritorno;
void setLength(int l);
void setBreadth(int b);
int area();
;
class Cube_Class: public Rectangle_Class
privato:
altezza intera;
pubblico:
Cube_Class (int h)
altezza=h;
int getHeight()
altezza di ritorno;
void setHeight(int h)
altezza=h;
volume intero()
return getLength()*getBreadth()*height;
;
Rettangolo_Classe::Rettangolo_Classe()
lunghezza=1;
larghezza=1;
Rectangle_Class::Rectangle_Class(int l,int b)
lunghezza=l;
larghezza=b;
Rectangle_Class::Rectangle_Class(Rectangle_Class &r)
lunghezza=r.lunghezza;
larghezza=r.larghezza;
void Rectangle_Class::setLength(int l)
lunghezza=l;
void Rectangle_Class::setBreadth(int b)
larghezza=b;
int Rectangle_Class::area()
ritorno lunghezza*larghezza;
intero principale()
Cube_Class c(8);
c.setLength(12);
c.setBreadth(9);
cout<<"Volume is "<
Conclusione:
In questo articolo ho spiegato il concetto di Ereditarietà in C++. Il C++ supporta diversi tipi di ereditarietà inclusa "ereditarietà multipla" (i.e., ereditare caratteristiche da più classi base o classi padre). Tuttavia, per semplificare, ho considerato solo l'ereditarietà singola qui. Ho mostrato tre esempi funzionanti per spiegare come possiamo usare l'ereditarietà nella programmazione C++ e riutilizzare il codice. Inoltre, questa è una caratteristica molto utile di C++.
