Tutto quello che devi sapere sull'ereditarietà in C ++

Questo articolo ti fornirà una conoscenza dettagliata e completa dell'ereditarietà in C ++, dei suoi vari tipi e di come implementarla.

C ++ è un linguaggio orientato agli oggetti. L'astrazione dei dati, il polimorfismo, l'incapsulamento e l'ereditarietà sono i cardini di OOP. In questo post capiremo cos'è l'eredità? Tipi di ereditarietà in C ++ e tutti i concetti necessari ad essa correlati da zero. Alla fine, esamineremo anche l'inconveniente di questo potente concetto e cercheremo di risolverlo.

Cos'è l'ereditarietà in C ++

L'ereditarietà è uno dei concetti più potenti e ampiamente utilizzati in C ++ o in qualsiasi altro linguaggio orientato agli oggetti. La comprensione di questo concetto richiede una piccola conoscenza delle classi e degli oggetti. Usando l'ereditarietà, possiamo creare una classe composta da metodi e attributi generali. Questa classe può essere ereditata da altre classi contenenti metodi più specifici.





Ereditarietà in C ++

In questo modo non dobbiamo scrivere le stesse funzionalità ancora e ancora, il che consente di risparmiare tempo e aumenta la leggibilità del codice.



Sintassi:

classe derivata_class: access_type base_class {// class body}

Classe base: La classe che consiste di tutti i metodi e attributi generali che possono essere condivisi da altre classi per aumentare la leggibilità del codice è chiamata classe base.

Classe derivata: La classe che consiste in metodi più specifici ed eredita una classe è chiamata classe derivata. Una classe derivata può anche essere una classe base per un'altra classe derivata.



Se creiamo una classe XYZ, con alcuni attributi e metodi. Ora uno studente di classe avrà alcuni altri attributi, ma includerà anche gli elementi della classe XYZ e lo stesso vale per una classe di facoltà. Vediamo un diagramma:

system.exit (1) java

Quindi, lo studente e il corpo docente erediteranno da XYZ.

Identificatore di accesso Abbiamo capito come una classe può ereditare un'altra classe. Ma alcune persone potrebbero dire che è un metodo non sicuro poiché tutti gli attributi e metodi della classe base o della classe genitore sono condivisi con la classe figlia o la classe derivata. Ad esempio, se una classe 'Banca' viene ereditata dalla classe 'clienti' e 'investitori'. Attributi della classe 'Banca' come 'password vault', altre informazioni relative ai clienti e dati privati ​​vengono condivisi con la classe 'clienti' e 'investitori' che non è sicura.

Per risolvere il problema precedente, C ++ utilizza gli specificatori di accesso per limitare l'accesso degli attributi della classe di base alla classe derivata. Ci sono un totale di 3 tipi di specificatori di accesso in C ++

  1. Pubblico
  2. Privato
  3. Protetto

La tabella seguente fornirà una buona comprensione del tipo di dati a cui è possibile accedere dalla classe derivata in base ai diversi specificatori di accesso.

Identificatore di accesso Dati pubblici Dati privati Dati protetti
Privato Non ereditatoNon ereditatoNon ereditato
Protetto Protetto Privato Protetto
Pubblico Pubblico Privato Protetto

Ereditarietà singola

L'ereditarietà singola può essere considerata come la semplice forma di eredità vanigliata. Nell'ereditarietà singola, una singola classe eredita da una classe base.

#include using namespace std class Train {int Numberofwheels int Numberofcoaches public: void Traininfo (int n, int m) {Numberofwheels = n Numberofcoaches = m} void showinfo () {cout<Questo caso di eredità è chiamato eredità multilivello. La classe tra la prima e l'ultima classe è anche nota come classe base intermedia.Cosa ne pensi, l'ultima classe può ereditare i membri della prima classe? Sì, può

#include using namespace std class First {protected: int a public: void getinfofirst (int x) {a = x} void showinfofirst () {std :: cout<< 'Value of a = ' < 

Produzione:

Valore di a = 10

Valore di b = 20

Valore di c = 30

Valore di d = 50

Ereditarietà gerarchica

Alcuni problemi non possono essere risolti con l'aiuto dell'eredità a uno o più livelli. Nell'ereditarietà gerarchica, più di una classe eredita da una singola classe di base.

#include using namespace std class College {public: College () {cout<< 'We are in class College' << endl } } class Student: public College { } class Faculty: public College { } int main() { Student student Faculty faculty return 0 }

Produzione:

Siamo in classe College

come impostare il percorso java

Siamo in classe College

Ereditarietà multipla in C ++

Abbiamo visto nell'ereditarietà gerarchica che una classe base aveva più di una classe derivata. Nell'ereditarietà multipla una classe derivata ha più di una classe base.

#include using namespace std class One {protected: int a public: void getinfoOne (int x) {a = x}} class Two {protected: int b public: void getinfoTwo (int y) {b = y}} class Main: public One, public Two {public: void Display () {std :: cout<< 'Value of a = ' < A questo punto, abbiamo una buona conoscenza di tutti i tipi di ereditarietà utilizzati in C ++. Ma, aspetta cosa succede se vogliamo usare 2 diversi tipi di ereditarietà? È possibile? Sì, è possibile con l'aiuto dell'ereditarietà ibrida. Nell'ereditarietà ibrida, combiniamo 2 diversi tipi di ereditarietà. Ad esempio: ereditarietà multilivello e multipla, ereditarietà gerarchica e multipla, ecc.

#include using namespace std class World {protected: int a public: void getinfoWorld (int x) {a = x}} class Continent: public World {protected: int b public: void getinfoContinent (int y) {b = y}} class Country {protected: int d public: void getinfoCountry (int m) {d = m}} class Australia: public Continent, public Country {public: void Display () {std :: cout<< 'Value of a = ' < 

Comprendiamo il diagramma sopra che ci aiuterà a comprendere il problema del diamante. la classe B e la classe C ereditano dalla classe A quindi sia la classe A che la classe B hanno attributi e metodi della classe A. se la classe D eredita dalla classe B e dalla classe C. la classe D avrà tutti gli attributi della classe B e della classe C Ha anche tutti gli attributi della classe A ereditati dalla classe B e dalla classe C. quindi se creiamo un oggetto di classe D e chiamiamo un metodo di classe A. verrà creata una situazione ambigua e il compilatore verrà confuso da dove dovrebbe classificare il metodo di A, dalla classe B o dalla classe D.

Per risolvere questa ambiguità utilizziamo un concetto chiamato classe base virtuale. Quando trasformiamo una classe base in una classe base virtuale, viene ereditata solo una copia di quella classe indipendentemente dal numero di percorsi esistenti tra la classe base virtuale e una classe derivata.

classe A {} classe B: pubblico virtuale A {} classe C: pubblico virtuale A {} classe D: pubblico C, pubblico D {}

Con questo, arriviamo alla fine di questo articolo sull'ereditarietà in C ++. Se desideri saperne di più, dai un'occhiata al da Edureka, una società di apprendimento online affidabile. Il corso di formazione e certificazione Java J2EE e SOA di Edureka è progettato per formarti sia sui concetti di base che avanzati su Java insieme a vari framework Java come Hibernate e Spring.

Hai domande per noi? Per favore, menzionalo nella sezione commenti di questo blog e ti risponderemo il prima possibile.

come utilizzare il browser db per sqlite