inheritance c
Importància de l'herència en C ++ amb exemples:
L’herència és una de les característiques més importants de la programació orientada a objectes.
L’herència és la tècnica mitjançant la qual una classe adquireix les propietats i mètodes d’una altra classe. D’aquesta manera podem reutilitzar el codi que ja està escrit i verificat. La classe que adquireix les propietats d’una altra classe s’anomena subclasse o classe derivada o classe secundària.
La classe les propietats de la qual s’adquireixen s’anomena classe base o classe pare o superclasse. Quan una classe adquireix o hereta una altra classe, totes les propietats i mètodes de la classe base estan disponibles per a la classe derivada, de manera que podem reutilitzar aquest codi.
=> Visiteu aquí per aprendre C ++ des de zero.
quin tipus de prova s’utilitza per verificar que tots els programes d’una aplicació funcionen correctament?
Què aprendreu:
- Per què necessitem l’herència?
- Modes d’herència
- Ordre de constructors / destructors en herència
- Tipus d’herència
- Herència de plantilles
- Composició
- Com hem de decidir entre composició i herència?
- Conclusió
- Lectura recomanada
Per què necessitem l’herència?
Penseu en un grup de vehicles com ara cotxe, autobús, jeep, etc. Cadascun d'aquests vehicles tindrà propietats i mètodes tal com s'indica al diagrama següent.
Si se’ns exigeix la implementació de classes individuals per als vehicles anteriors, podem veure que en les tres classes haurem d’escriure el mateix codi que els tres tipus de vehicles que presenten més o menys les mateixes propietats. Això farà que el nostre programa sigui ineficient i pesat, ja que hi haurà molts codis duplicats.
En lloc d’escriure un codi duplicat com l’anterior, podem implementar la característica d’herència per evitar que es dupliqui el codi i també escriure un sol fragment de codi i utilitzar-lo a les tres classes. Això es representa pictòricament a continuació.
A la figura anterior, hem definit una classe base 'Vehicles' i hem derivat les classes Car, Bus i Jeep d'aquesta classe. Els mètodes i propietats habituals formen part de la classe Vehicles ara. Com que altres classes es deriven de la classe Vehicles, totes les classes adquireixen aquests mètodes i propietats.
Per tant, només hem d’escriure el codi comú només una vegada i les tres classes; Car, Bus i Jeep l’adquiriran.
Per tant, el principal avantatge que obtenim heretant les classes existents o dissenyant un mecanisme d’herència és la reutilització del codi.
Lectures addicionals = >> Tutorial sobre herència de Java
El format general per heretar una classe és:
class derived_classname: access_specifier base_classname { }; Aquí “ nom_classe_derivat 'És el nom de la classe derivada,' especificador_accés 'És el mode d'accés, és a dir, públic, protegit o privat, en què la classe derivada ha d'heretar la classe base i' nom_classe_derivat ”És el nom de la classe base de la qual hereta la classe derivada.
Modes d’herència
L ''access_specifier' que es mostra a la declaració d'herència anterior pot tenir els seus valors com es mostra a continuació.
Depenent de l'access_specifier especificat quan heretem la classe, disposem de diversos modes d'herència que es detallen a continuació.
Herència pública
Sintaxi general
class sub_class : public parent_class Quan s'especifica un especificador d'accés públic, els membres públics de la classe base s'hereten com a públics mentre es protegeixen els membres protegits. Els membres privats continuen sent privats. Aquest és el mode d’herència més popular.
Herència privada
Sintaxi general
class sub_class : parent_class L’herència privada no hereta res. Quan s'utilitza un especificador d'accés privat, els membres públics i protegits de la classe base també passen a ser privats.
Herència protegida
Sintaxi general
class sub_class:protected parent_class Quan s'utilitza un especificador d'accés protegit, els membres públics i protegits de la classe base es converteixen en membres protegits de la classe derivada.
preguntes d’entrevistes dirigides per equips basades en escenaris
Tingueu en compte que quan fem servir un especificador d'accés privat per a la classe base, no s'hereta cap dels membres de la classe base. Tots esdevenen privats de la classe derivada.
A continuació es mostra la representació tabularitzada de tots els modes d’accés i la seva interpretació per herència.
| Classe derivada -> Classe base | Privat | Públic | Protegit |
|---|---|---|---|
| Privat | No heretat | No heretat | No heretat |
| Públic | Privat | Públic | Protegit |
| Protegit | Privat | Protegit | Protegit |
Ordre de constructors / destructors en herència
Quan s’hereten classes, els constructors s’anomenen en el mateix ordre que s’hereten les classes. Si tenim una classe base i una classe derivada que hereta aquesta classe base, el constructor de classes base (ja sigui per defecte o parametritzat) s'anomenarà primer seguit del constructor de classes derivades.
El programa següent mostra l'ordre dels constructors en herència. Tenim una classe Base 'Base' que té un constructor per defecte i un constructor parametritzat. D’aquesta manera, derivem una classe anomenada “Derivat”, que també té un constructor parametricitzat i un altre per defecte.
La sortida d’aquest programa mostra l’ordre en què s’anomenen els constructors.
#include using namespace std; //order of execution of constructors in inheritance class Base { int x; public: // default constructor Base() { cout Sortida:
Constructor per defecte de la classe base
Constructor per defecte de la classe base
Constructor per defecte de classe derivat
Constructor parametritzat de classe base
Constructor parametritzat de classe derivada
Veiem que després de crear l’objecte de classe base creem un objecte de classe derivat amb un constructor per defecte. Quan es crea aquest objecte, primer es diu el constructor per defecte de la classe base i després s'executa el constructor de classes derivat.
De la mateixa manera, quan l'objecte de classe derivat es crea mitjançant el constructor parametritzat, primer s'anomena el constructor parametritzat de classe base i després es diu el constructor de classes derivat.
Tingueu en compte que si no hi hagués cap constructor parametritzat a la classe base, el constructor per defecte s'hauria cridat fins i tot per construir l'objecte de classe derivat parametritzat.
Però queda la pregunta de per què es crida al constructor de classes base mentre es construeixen els objectes de classe derivats?
Sabem que s’utilitza un constructor per crear objectes de la classe i també per inicialitzar els membres de la classe. Quan es crea l'objecte de classe derivat, el seu constructor només té control sobre els membres de classe derivats.
Tanmateix, la classe derivada també hereta els membres de la classe base. Si només es cridés el constructor de classes derivades, els membres de la classe base heretats per la classe derivada no s’inicialitzarien correctament.
Com a resultat, l’objecte sencer no es crearà de manera eficient. Aquesta és la raó per la qual tots els constructors de classes base s’anomenen primer quan es crea un objecte de classe derivat.
Tipus d’herència
Depenent de la forma en què es derivi la classe o de quantes classes base hereta una classe, tenim els següents tipus d'herència tal com es mostra a la figura següent.
Explorarem cadascun d’aquests tipus al nostre següent tutorial sobre “Tipus d’herència”.
Herència de plantilles
Quan la nostra implementació implica plantilles, hem d’heretar o derivar de classes de plantilles i fer-hi ús de l’herència de plantilles.
Passem directament a un exemple de programació per entendre millor l'herència mitjançant plantilles.
#include using namespace std; //template inhertance templateclass basecls_Template { public: T value; basecls_Template(T value) { this->value = value; } void displayVal() { cout << value << endl; } }; //derived class inherits basecls_Template class derivedcls_Child : public basecls_Template { public: derivedcls_Child(/* no parameters */): basecls_Template( 0 ){ // default char is NULL; } derivedcls_Child(char c): basecls_Template( c ) { ; } void displayVal_drvd() { displayVal(); } }; int main() { basecls_Template obj( 100 ); derivedcls_Child obj1( 'A' ); cout<<'basecls_Template obj = '; obj.displayVal(); // should print '100' cout< Sortida:
basecls_Template obj = 100
derivcls_Child obj1 (heretat de basecls_Template = A
Al programa anterior, tenim una plantilla anomenada basecls_Template que defineix la plantilla de classe per a la classe base. A continuació, definim una classe derivcls_Child que volem derivar d'una classe de plantilla.
Tingueu en compte que la classe basecls_Template només és un tipus i no una classe. Per tant, no podem derivar la classe derivcls_Child d'aquesta plantilla.
Per tant, si declarem la classe infantil com:
class derivedcls_Child : public basecls_Template Això provocarà un error. La raó de ser basecls_Template és un tipus de dades i no una classe. Per tant, per heretar els membres de basecls_Template, primer hauríem d’instanciar-lo abans de derivar-ne.
Per tant, l'afirmació anterior, Classe provencls_Child: public basecls_Template funciona bé.
En aquesta afirmació, hem instanciat la plantilla basecls_Template a una plantilla de classe de caràcters. Un cop utilitzem aquesta classe de plantilla instantània, les altres coses següents, com ara crear i utilitzar objectes, coincideixen amb el funcionament habitual de l'herència.
Composició
Fins ara hem vist tot sobre les relacions d’herència. L’herència representa bàsicament el tipus de relacions en què la relació indica una part. Per exemple, una serp és una mena de rèptil. També podem dir que el rèptil forma part de la classe Animal.
En conclusió, l’herència indica 'ÉS UN' tipus de relacions en què podem dir que la classe derivada és una part de la classe base.
També podem representar les relacions en el seu conjunt. Per exemple, si diem que la classe de salari forma part de la classe dels empleats, no la representem correctament. Sabem que els empleats tenen un sou. Per tant, és més convenient dir 'L'empleat té un salari'.
De la mateixa manera, si prenem la classe Vehicles com a exemple, podem dir que el vehicle té motor o que el vehicle té xassís. Així es representen totes aquestes relacions 'TÉ' relacions que representen tot un objecte contingut en una altra classe. Això es defineix com Composició .
Les relacions representades per la composició depenen les unes de les altres. Per exemple, un xassís no pot existir sense un vehicle. De la mateixa manera, el salari no pot existir sense un empleat.
Podem representar la composició de forma esquemàtica com es mostra a continuació:
La composició també es denomina Contenció. A la representació anterior, hem mostrat una classe pare. A diferència de l’herència, incloem un objecte de classe fill dins de la classe pare. Es tracta de contenció o composició.
Preguntes i respostes d’entrevistes d’oracle pl / sql
Prenem un exemple de programació per entendre-ho.
#include using namespace std; //Composition example //Child class - address class Address { public: string houseNo, building, street, city, state; //Initialise the address object Address(string houseNo,string building,string street, string city, string state) { this->houseNo = houseNo; this->building = building; this->street = street; this->city = city; this->state = state; } }; //Parent class - Employee class Employee { private: Address* address; //composition->Employee has an address public: int empId; string empName; Employee(int empId, string empName, Address* address) { this->empId = empId; this->empName = empName; this->address = address; } void display() { cout< Sortida:
10001 Ved
A-101 Silver Springs Aundh Pune Maharashtra
En aquest exemple, tenim una classe principal Employee i una classe secundària Address. Dins de la classe pare Employee, hem declarat un punter a la classe Address i també inicialitzem aquest objecte al constructor Employee. Per tant, representem la relació que el treballador té una adreça que és la composició.
Com hem de decidir entre composició i herència?
La composició i l’herència representen les relacions entre classes. Tot i que l’herència representa la relació “IS-A”, la composició representa la relació “HAS-A”.
Ara la pregunta és: quan hem d’utilitzar l’herència i quan hem d’utilitzar la composició? En realitat, no podem decidir sobre les situacions exactes com quan hauríem d’utilitzar-ne cap. Això es deu al fet que cadascun té els seus propis avantatges i desavantatges.
Tots dos promouen la reutilització del codi. L'herència pot fer que el codi sigui voluminós a mesura que les solucions esdevenen complexes, però al mateix temps, també ens permet ampliar el codi existent. Per tant, hauríem d’utilitzar l’herència quan el nostre requisit és modificar i utilitzar les propietats i el mètode d’una altra classe dins de la nova classe.
En altres paraules, quan volem afegir més propietats i ampliar la classe existent. D’altra banda, quan no volem modificar les propietats i el comportament d’una altra classe, sinó que simplement l’utilitzem dins de la classe, optem per la composició.
Per tant, la millor decisió és si s’utilitzarà la composició o l’herència, prenent en consideració els pros i els contres d’ambdues tècniques per a la situació particular.
= >> Llegiu també Composició a Java
Conclusió
Per tant, hem arribat al final del nostre tema sobre l'herència. Hem vist diversos modes d’herència. També hem vist els tipus d’herència que explorarem al nostre proper tutorial. Vam conèixer l’ordre dels constructors que s’executen en cas d’herència.
També hem estudiat sobre plantilles i herència. Cal instanciar una plantilla abans de poder utilitzar-la en herència, ja que la mateixa plantilla és un tipus de dades i no podem heretar d’un tipus de dades.
La composició és un altre tipus de relació de classe i primer hem de conèixer la situació exacta i després només podem decidir si fem servir composició o herència.
Al nostre proper tutorial, veurem més informació sobre els tipus d’herència.
=> Mireu aquí la sèrie d'entrenament C ++ simple.
Lectura recomanada
- Tipus d’herència en C ++
- Polimorfisme en temps d'execució en C ++
- Funcions d'amistat a C ++
- Ús de la classe Selenium Select per a la manipulació d’elements desplegables en una pàgina web - Tutorial Selenium # 13
- Classes i objectes en C ++
- Estàtic a C ++
- Tutorial Unix Pipes: Pipes a la programació Unix
- Interfície Java i tutoria de classes abstractes amb exemples
