Ereditarietà C++

C Inheritance



L'ereditarietà è 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 il concetto di ereditarietà nella programmazione C++. Spiegheremo il concetto della funzione friend in C++ con esempi funzionanti.







Perché eredità?

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 padre o della classe base. Possiamo riutilizzare il codice con l'aiuto dell'ereditarietà.



Tipo di eredità

Esistono diversi tipi di ereditarietà:



  1. Ereditarietà semplice/singola
  2. Eredità gerarchica
  3. Ereditarietà multilivello
  4. 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.

#includere

usando lo spazio dei nomi std;

class Base_Class
{
pubblico:
intio;
vuotoSchermo()
{
costo<< 'Visualizzazione della classe base' <<io<<fine;
}

};

class Derived_Class:pubblico Base_Class
{
pubblico:
vuotomostrare()
{
costo<< 'Mostra di classe derivata' <<fine;
}
};

intprincipale()
{
Derived_Class dc;
dc.io = 100;
dc.Schermo();
dc.mostrare();

Restituzione 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 di chiamare il costruttore della classe derivata.

#includere
usando lo spazio dei nomi std;

class Base_Class
{
pubblico:
Classe_base()
{
costo<< 'Classe_base - Nessun parametro' <<fine;
}
Classe_base(intX)
{
costo<< 'Classe_Base - Parametri: ' <<X<<fine;
}
};

class Derived_Class:pubblico Base_Class
{
pubblico:
Classe_derivato()
{
costo<< 'Classe_derivato - Nessun parametro' <<fine;
}
Classe_derivato(inte)
{
costo<< 'Classe_derivata - Parametri: ' <<e<<fine;
}
Classe_derivato(intX,inte):Classe_base(X)
{
costo<< 'Param di Derived_Class : ' <<e<<fine;
}
};

intprincipale()
{
Derived_Class 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 deriva la classe derivata, ovvero Cube_Class. 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, ovvero setLength() e setBreadth().

#includere

usando lo spazio dei nomi std;

class Rectangle_Class
{
privato:
intlunghezza;
intampiezza;
pubblico:
Rectangle_Class();
Rectangle_Class(intl,intB);
Rectangle_Class(Rectangle_Class&R);
intottenereLength()
{
Restituzionelunghezza;
}
intottenereBreadth()
{
Restituzioneampiezza;
}
vuotosetLength(intl);
vuotosetBreadth(intB);
intla zona();
};

class Cube_Class:Public Rectangle_Class
{
privato:
intaltezza;
pubblico:
Cube_Class(inth)
{
altezza=h;
}
intgetHeight()
{
Restituzionealtezza;
}
vuotosetHeight(inth)
{
altezza=h;
}
intvolume()
{
RestituzioneottenereLength()*ottenereBreadth()*altezza;
}
};


Rectangle_Class::Rectangle_Class()
{
lunghezza=1;
ampiezza=1;
}
Rectangle_Class::Rectangle_Class(intl,intB)
{
lunghezza=l;
ampiezza=B;
}
Rectangle_Class::Rectangle_Class(Rectangle_Class&R)
{
lunghezza=R.lunghezza;
ampiezza=R.ampiezza;
}
vuotoRectangle_Class::setLength(intl)
{
lunghezza=l;
}
vuotoRectangle_Class::setBreadth(intB)
{
ampiezza=B;
}
intRectangle_Class::la zona()
{
Restituzionelunghezza*ampiezza;
}

intprincipale()
{
Cube_Class c(8);
C.setLength(12);
C.setBreadth(9);
costo<<'Il volume è'<<C.volume()<<fine;
}

Conclusione:

In questo articolo ho spiegato il concetto di eredità in C++ . Il C++ supporta diversi tipi di ereditarietà inclusa l'ereditarietà multipla (ovvero ereditando funzionalità da più classi base o classi genitore). Tuttavia, per semplificare, qui ho considerato solo l'ereditarietà singola. Ho mostrato tre esempi funzionanti per spiegare come possiamo usare l'ereditarietà nella programmazione C++ e riutilizzare il codice. Inoltre, questa è una funzionalità molto utile del C++.