C ++ eredità

L'eredità è una caratteristica molto importante della programmazione orientata agli oggetti. Consente al programmatore di derivare una classe da una classe esistente. Questo è molto utile soprattutto in un grande progetto complesso perché consente al programmatore di riutilizzare il codice.

In questo articolo, discuteremo del concetto di eredità nella programmazione C ++. Spiegheremo il concetto della funzione dell'amico in C ++ con esempi di lavoro.

Perché l'eredità?

L'eredità consente di creare una nuova classe o una classe derivata da un'altra classe o classe base. La classe derivata o la classe figlio avrà tutte le caratteristiche della classe genitore o della classe base. Possiamo riutilizzare il codice con l'aiuto dell'eredità.

Tipo di eredità

Esistono diversi tipi di eredità:

1. Eredità semplice/singola
2. Ereditarietà gerarchica
3. Ereditarietà multilivello
4. Ereditarietà multipla

In questo articolo, considereremo solo un'eredità semplice/singola.

Esempio 1:

Ora, esaminiamo un programma di esempio per comprendere il concetto di eredità in C++. Abbiamo definito una classe di base e poi ne abbiamo derivato un'altra classe. Pertanto, la classe derivata avrà le caratteristiche (membri e funzioni) della classe base.

#includere
Utilizzo dello spazio dei nomi std;
Classe Base_Class

pubblico:
int i;
vuoto display ()

cout << "Display of Base Class " << i << endl;

;
Classe Derited_Class: Public Base_Class

pubblico:
void show ()

cout << "Show of Derived Class" << endl;

;
int main ()

Derited_Class DC;
DC.i = 100;
DC.Schermo();
DC.spettacolo();
restituzione 0;

Esempio 2:

Questo è un altro esempio di eredità in C++. In questo esempio, vedremo come vengono chiamati i costruttori quando viene creato un oggetto di classe derivato.

Come puoi vedere di seguito, abbiamo definito due costruttori di classe base e tre costruttori di classe derivata. È possibile notare chiaramente dall'output seguente che il costruttore di classe di base viene chiamato prima prima che il costruttore di classe derivata venga chiamata.

#includere
Utilizzo dello spazio dei nomi std;
Classe Base_Class

pubblico:
Base_class ()

cout << "Base_Class - No Parameters" << endl;

Base_class (int x)

cout << "Base_Class - Parameters : " << x << endl;

;
Classe Derited_Class: Public Base_Class

pubblico:
Derited_class ()

cout << "Derived_Class - No Parameters" << endl;

Derited_class (int y)

cout << "Derived_Class - Parameters : " << y << endl;

DeriD_Class (int x, int y): base_class (x)

cout << "Param of Derived_Class : " << y << endl;

;
int main ()

Derited_Class D (7,19);

Esempio 3:

In questo esempio, vedremo come possono essere usati gli oggetti di classe derivati.

Come puoi vedere, ci sono due classi definite: RecTangle_Class e Cube_Class. Rectangle_class è la classe base da cui la classe derivata, i.e., Cube_class è derivato. Pertanto, stiamo ereditando 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, quindi chiamiamo i metodi della classe base, i.e., setLength () e setBreadth ().

#includere
Utilizzo dello spazio dei nomi std;
Classe RecTangle_Class

privato:
lunghezza int;
int larghezza;
pubblico:
RecTangle_class ();
Rectle_class (int l, int b);
Rectle_class (rectangle_class & r);
int getLength ()

Lunghezza di ritorno;

int getBreadth ()

restituire l'ampiezza;

void setLength (int l);
void setBreadth (int b);
int area ();
;
Class Cube_Class: rettangolo pubblico_class

privato:
Altezza int;
pubblico:
Cube_class (int h)

altezza = h;

int getheight ()

altezza di ritorno;

void setheight (int h)

altezza = h;

int volume ()

return getLength ()*getBreadth ()*altezza;

;
RecTangle_class :: rectangle_class ()

lunghezza = 1;
Larghezza = 1;

RecTangle_class :: rectangle_class (int l, int b)

lunghezza = l;
Larghezza = B;

RECTALGLE_CLASS :: RECTANGLE_CLASS (RECTANGLE_CLASS & R)

lunghezza = r.lunghezza;
Larghezza = r.ampiezza;

void rectangle_class :: setLength (int l)

lunghezza = l;

void rectangle_class :: setBreadth (int b)

Larghezza = B;

int rettangle_class :: area ()

Lunghezza di ritorno*ampiezza;

int main ()

Cube_class c (8);
C.setLength (12);
C.SetBreadth (9);
cout<<"Volume is "<

Conclusione:

In questo articolo, ho spiegato il concetto di eredità in C++. Il C ++ supporta diversi tipi di eredità tra cui "eredità multipla" (i.e., Caratteristiche ereditarie da più classi di base o classe genitore). Tuttavia, per renderlo più semplice, ho considerato solo una singola eredità qui. Ho mostrato tre esempi di lavoro per spiegare come possiamo usare l'eredità nella programmazione C ++ e riutilizzare il codice. Inoltre, questa è una caratteristica molto utile di C++.