Tipi di ereditarietà in C++ Cosa dovresti sapere?

Ti sei mai chiesto come sono costruiti alcuni sistemi software popolari? È tutto grazie a un potente meccanismo chiamato ereditarietà nella programmazione orientata agli oggetti (OOP). L'ereditarietà consente ai programmatori di creare nuove classi basate su quelle esistenti, consentendo il riutilizzo del codice e uno sviluppo efficiente del software. Immagina di costruire un sistema che richiede diverse classi, ognuna delle quali condivide alcuni attributi e comportamenti comuni.

Invece di scrivere ripetutamente lo stesso codice, puoi usare l'ereditarietà per creare una classe base e derivarne nuove classi, risparmiando tempo e fatica.

L'ereditarietà non è solo efficiente ma anche versatile. In C++ esistono diversi tipi di ereditarietà, ciascuno con vantaggi e casi d'uso unici.

In questo articolo, daremo uno sguardo completo ai diversi tipi di ereditarietà in C++ , fornendo codici pertinenti, spiegazioni ed esempi di vita reale in tutto l'articolo.

Diversi tipi di ereditarietà in C++

Il linguaggio di programmazione C++ offre cinque diversi tipi di opzioni di ereditarietà ai suoi programmatori. A seconda del contesto e dei requisiti, sviluppatori e programmatori possono lavorare con uno di questi tipi di ereditarietà.

Unica eredità

L'ereditarietà singola è il tipo più comune di ereditarietà in C++. Nell'ereditarietà singola, una classe derivata eredita da una singola classe base. Ciò significa che una classe eredita tutti i membri dati pubblici e protetti e le funzioni membro della classe base pur avendo la possibilità di aggiungere i propri membri dati e funzioni membro.

Controlla lo snippet di codice qui sotto per ottenere la sintassi e la comprensione dell'ereditarietà singola:

// Classe base

classe Animale {

pubblico:

vuoto mangiare() {

std::cout << “L'animale sta mangiando” << std::endl;

}

};

// Classe derivata

classe Cane : public Animale {

pubblico:

corteccia vuota() {

std::cout << “Il cane abbaia” << std::endl;

}

};

In questo esempio, abbiamo una classe base chiamata Animal con una singola funzione membro eat().Definiamo quindi una classe derivataDog che eredita pubblicamente da Animal.Dog ha anche la sua funzione membro bark().Utilizzando l'ereditarietà singola,Dog può accedere alla funzione eat()dellaclasse Animale aggiungere il proprio comportamento con lafunzione bark().

Quando utilizzare l'ereditarietà singola in C++

I programmatori possono utilizzare l'ereditarietà singola per creare una classe derivata che aggiunge funzionalità alla classe base.

Ad esempio, puoi utilizzare l'ereditarietà singola quando crei un gioco che coinvolge personaggi diversi, come guerrieri, maghi e arcieri. Tutti questi personaggi condividono alcuni attributi e comportamenti comuni, come punti salute, potenza di attacco e velocità di movimento. Utilizzando l'ereditarietà singola, è possibile creare una classe di base denominata Character che contiene gli attributi e i comportamenti comuni e derivare ogni classe di caratteri da essa per aggiungere la loro funzionalità univoca.

Nell'ereditarietà multipla, una classe derivata può ereditare da più classi di base. Ciò significa che una classe può avere più di una classe genitore diretta. Di conseguenza, la classe derivata eredita tutti i membri dati pubblici e protetti e le funzioni membro di ogni classe base.

Ecco un esempio di ereditarietà multipla:

// Classe base 1

classe Forma {

pubblico:

doppia area virtuale() = 0;

};

// Classe base 2

classe Colore {

pubblico:

virtual std::string getColor() = 0;

};

// Classe derivata

class Rectangle : public Shape, public Color {

pubblico:

double area() sovrascrive {

ritorno larghezza * altezza;

}

std::string getColor() sovrascrive {

restituire il colore;

}

privato:

doppia larghezza = 5,0;

doppia altezza = 3,0;

std::string color = “blu”;

};

In questo esempio, abbiamo due classi base, Shape e Color , ciascuna con la sua funzione virtuale.Definiamo quindi una classe derivataRectangle che eredita sia da Shape che da Color.Rectangle esegue l'override delle funzioni virtuali di entrambe le classi di base per fornire la propria implementazione. Usando l'ereditarietà multipla,Rectangle può ereditare le proprietà di entrambe le classi di base, ShapeeColor, per creare un rettangolo con un colore e un'area specifici.

Quando utilizzare l'ereditarietà multipla in C++

Utilizzare l'ereditarietà multipla quando si desidera combinare funzionalità da più classi di base. Ad esempio, considera un'applicazione GUI che richiede diversi tipi di controlli, come pulsanti, caselle di controllo e caselle di testo. Ogni tipo di controllo ha la sua funzionalità e il suo comportamento, ma condividono anche alcune funzionalità comuni, come la gestione degli eventi utente e la visualizzazione del testo.

Utilizzando l'ereditarietà multipla, è possibile creare una classe base denominataControl che contiene la funzionalità comune e derivare ogni tipo di controllo da essa, nonché altre classi base che contengono la funzionalità specifica.

Nell'ereditarietà gerarchica, una singola classe di base viene ereditata da più classi derivate. Analogamente all'ereditarietà multipla, le classi derivate nell'ereditarietà gerarchica ottengono tutti i membri dati pubblici e protetti e le funzioni membro della classe base.

Ecco un frammento di codice per aiutarti a comprendere l'implementazione dell'ereditarietà gerarchica in C++:

// Classe base

classe Animale {

pubblico:

vuoto virtuale makeSound() = 0;

};

// Classe derivata 1

class Gatto : public Animale {

pubblico:

void makeSound() sovrascrive {

std::cout << “Miao” << std::endl;

}

};

// Classe derivata 2

classe Cane : public Animale {

pubblico:

void makeSound() sovrascrive {

std::cout << “Bau” << std::endl;

}

};

In questo esempio, abbiamo una classe base chiamata Animal con una funzione virtuale makeSound().Definiamo quindi due classi derivate,Cat e Dog, che ereditano entrambe daAnimal. Ogni classe derivata sovrascrive la funzionemakeSound() per fornire la propria implementazione.Usando l'ereditarietà gerarchica, possiamo creare diversi tipi di animali che condividono comportamenti comuni, come emettere un suono.

Quando usare l'ereditarietà gerarchica in C++

Utilizzare l'ereditarietà gerarchica quando si desidera creare più classi derivate che condividono funzionalità comuni. Ad esempio, si consideri un'applicazione bancaria che richiede diversi tipi di conti, come conti di risparmio, conti correnti e conti di carte di credito. Tutti questi tipi di conto condividono alcuni attributi e comportamenti comuni, come il numero di conto, il saldo e il tasso di interesse.

Utilizzando l'ereditarietà gerarchica, è possibile creare una classe base denominata Account che contiene gli attributi e i comportamenti comuni e derivare ogni tipo di account da essa per aggiungere la sua funzionalità univoca.

Ereditarietà multilivello

L'ereditarietà multilivello in C++ è un tipo di ereditarietà in cui una classe derivata viene ereditata da un'altra classe derivata. In questo scenario, la classe derivata eredita tutti i membri di dati pubblici e protetti e le funzioni membro della sua classe genitore immediata, che a sua volta eredita dalla propria classe genitore e così via.

Ecco come implementare a livello di codice l'ereditarietà multilivello in C++:

// Classe base

classe Veicolo {

pubblico:

void start() {

std::cout << “Il veicolo sta partendo” << std::endl;

}

};

// Classe Intermedia

classe Auto : Veicolo pubblico {

pubblico:

void drive() {

std::cout << “L'auto sta guidando” << std::endl;

}

};

// Classe derivata

class SportsCar : public Car {

pubblico:

void accelera() {

std::cout << “L'auto sportiva sta accelerando” << std::endl;

}

};

Quando usare l'ereditarietà multilivello in C++

Utilizzare l'ereditarietà multilivello quando si desidera creare una classe derivata che erediti da un'altra classe derivata e ne aggiunga le funzionalità. Ad esempio, si consideri un sistema software che richiede diversi tipi di veicoli, come automobili, camion e motociclette. Questi tipi di veicoli condividono alcuni attributi e comportamenti comuni, come velocità, accelerazione e frenata.

Utilizzando l'ereditarietà multilivello, è possibile creare una classe base denominata Veicolo che contenga gli attributi e i comportamenti comuni e derivarne classi intermedie come AutoeCamionper aggiungere le loro funzionalità specifiche. Quindi, puoi derivare laclasse SportsCar dalla classe Carper aggiungere la sua funzionalità univoca.

L'ereditarietà ibrida è una combinazione di due o più tipi di ereditarietà. Definita anche ereditarietà virtuale, una classe derivata nell'ereditarietà ibrida eredita da più classi di base, alcune delle quali vengono ereditate attraverso più percorsi. Ciò può creare complesse gerarchie di ereditarietà e può essere difficile da comprendere e mantenere.

Dai un'occhiataai corsi di sviluppo software di upGradper migliorare te stesso.

Ecco un esempio di ereditarietà ibrida in C++:

// Classe base 1

classe Animale {

pubblico:

vuoto virtuale makeSound() = 0;

};

// Classe base 2

classe CanFly {

pubblico:

virtual void fly() = 0;

};

// Classe base 3

classe CanSwim {

pubblico:

virtual void swim() = 0;

};

// Classe derivata

class Pipistrello : public Animale, public CanFly {

pubblico:

void makeSound() sovrascrive {

std::cout << “Scricchiola!”<< std::endl;

}

void fly() sostituisci {

std::cout << “Il pipistrello sta volando” << std::endl;

}

};

// Classe derivata

class Penguin : public Animal, public CanSwim {

pubblico:

void makeSound() sovrascrive {

std::cout << “Hooonk!”<< std::endl;

}

void swim() sovrascrive {

std::cout << “Il pinguino sta nuotando” << std::endl;

}

};

Esplora i nostri famosi corsi di ingegneria del software

Quando utilizzare l'ereditarietà ibrida in C++

Oltre ai quattro tipi di ereditarietà discussi in precedenza, l'ereditarietà ibrida può essere utile in determinati scenari in cui sono richiesti più tipi di ereditarietà. Utilizza l'ereditarietà ibrida per combinare i vantaggi di più tipi di ereditarietà.

Ad esempio, considera un sistema software che richiede diversi tipi di animali, alcuni dei quali possono volare mentre altri possono nuotare. È possibile utilizzare l'ereditarietà ibrida per creare una classe base denominata Animal e derivarne due classi intermedie, CanFlyeCanSwim. Infine, utilizzando l'ereditarietà ibrida, è possibile derivare le classiBat e Penguinda entrambe le classi intermedie. La classeBat erediterà da AnimaleCanFly, mentre la classePenguinerediterà daAnimaleCanSwim. In questo modo, puoi creare diversi tipi di animali con combinazioni uniche di abilità.

L'ereditarietà ibrida in C++ può essere utile in sistemi software complessi in cui sono richiesti più tipi di ereditarietà. Tuttavia, può anche creare complesse gerarchie di ereditarietà che possono essere difficili da comprendere e mantenere. Come con altri tipi di ereditarietà, la scelta del tipo giusto per i requisiti specifici del progetto di sviluppo software e gli obiettivi di progettazione è fondamentale.

Leggi i nostri articoli popolari relativi allo sviluppo software

Dai un'occhiata ai nostricorsi di tecnologia gratuiti per avere un vantaggio sulla concorrenza.

Cose importanti da tenere a mente quando si utilizza l'ereditarietà:

Mentre l'ereditarietà è un potente meccanismo in C++, ha anche alcuni fattori da considerare durante l'implementazione.

1. Evita le gerarchie di ereditarietà profonde : le gerarchie di ereditarietà profonde possono portare a codice difficile da leggere, comprendere e mantenere.Mantieni le tue gerarchie di ereditarietà il più superficiale possibile per migliorare la leggibilità e la manutenibilità del codice.
2. Usa saggiamente i modificatori di accesso: i modificatori di accesso (pubblico, protetto e privato) controllano la visibilità dei membri dati e delle funzioni membro in una classe.Usali saggiamente per evitare di esporre dettagli di implementazione che non dovrebbero essere visibili al di fuori della classe.
3. Evitare l'ereditarietà Diamond: l'ereditarietà Diamond si verifica quando una classe eredita da due classi che ereditano dalla stessa classe base.Questo può portare ad ambiguità ed è generalmente meglio evitarlo.
4. Evita l'uso eccessivo dell'ereditarietà: mentre l'ereditarietà può essere utile, è importante evitarne l'uso eccessivo.In alcuni casi, la composizione o altri modelli di design possono essere una scelta migliore.

Esplora i nostri corsi gratuiti di sviluppo software

Porta via

Per riassumere, l'ereditarietà è un concetto cruciale nella programmazione C++ che ogni studente di programmazione dovrebbe padroneggiare. Comprendendo i diversi tipi di ereditarietà e i relativi casi d'uso, puoi creare codice efficiente, organizzato e gestibile, diventando così uno sviluppatore di software migliore.

Se hai trovato interessante questo articolo, puoi migliorare ulteriormente la tua conoscenza dello sviluppo software iscrivendoti al programma di certificazione DevOps di upGrad offerto in collaborazione con IIIT Bangalore. Questo programma copre vari aspetti dello sviluppo del software, tra cui codifica, test e distribuzione, e può aiutarti a diventare uno sviluppatore di software esperto nel settore.