En aquest article, analitzarem el concepte d’herència en la programació C ++. Explicarem el concepte de la funció amic en C ++ amb exemples de treball.
Per què l’herència?
L'herència permet crear una nova classe o classe derivada d'una altra classe o classe base. La classe derivada o la classe infantil tindran totes les característiques de la classe pare o classe base. Podem tornar a utilitzar el codi amb l'ajut de l'herència.
Tipus d’herència
Hi ha diferents tipus d’herència:
- Herència simple / única
- Herència jeràrquica
- Herència multinivell
- Herència múltiple
En aquest article, considerarem només l’herència simple / única.
Exemple 1:
Ara, examinem un exemple de programa per entendre el concepte d’herència en C ++. Hem definit una classe base i després n'hem derivat una altra. Per tant, la classe derivada tindrà les característiques (membres i funcions) de la classe base.
#incloureutilitzant l'espai de noms std;
classe Base_Class
{
públic:
intjo;
buitvisualització()
{
cost<< 'Visualització de la classe base' <<jo<<endl;
}
};
classe Derived_Class:Classe_Base pública
{
públic:
buitespectacle()
{
cost<< 'Espectacle de classe derivada' <<endl;
}
};
intprincipal()
{
Derived_Class dc;
dc.jo = 100;
dc.visualització();
dc.espectacle();
tornar 0;
}
Exemple 2:
Aquest és un altre exemple d’herència en C ++. En aquest exemple, veurem com es diuen els constructors quan es crea un objecte de classe derivat.
Com podeu veure a continuació, hem definit dos constructors de classes base i tres constructors de classes derivats. Podeu notar clarament per la sortida següent que el constructor de classes base s'anomena primer abans que s'anomeni el constructor de classes derivades.
#incloureutilitzant l'espai de noms std;
classe Base_Class
{
públic:
Classe_Base()
{
cost<< 'Base_Class: sense paràmetres' <<endl;
}
Classe_Base(intx)
{
cost<< 'Base_Class - Paràmetres:' <<x<<endl;
}
};
classe Derived_Class:Classe_Base pública
{
públic:
Classe_Derivada()
{
cost<< 'Derived_Class: sense paràmetres' <<endl;
}
Classe_Derivada(inti)
{
cost<< 'Derived_Class - Paràmetres:' <<i<<endl;
}
Classe_Derivada(intx,inti):Classe_Base(x)
{
cost<< 'Param de Derived_Class:' <<i<<endl;
}
};
intprincipal()
{
Classe_Derivada d(7,19);
}
Exemple 3:
En aquest exemple, veurem com es poden utilitzar objectes de classe derivats.
Com podeu veure, hi ha dues classes definides: Rectangle_Class i Cube_Class. Rectangle_Class és la classe base de la qual deriva la classe derivada, és a dir, Cube_Class. Per tant, heretem les funcions de Rectangle_Class a Cube_Class.
També podeu notar que heretem Cube_Class amb el control d’accés públic. Això significa que la classe derivada pot accedir a tots els membres no privats de la classe base.
Hem declarat un objecte de la classe derivada i, a continuació, anomenem els mètodes de la classe base, és a dir, setLength () i setBreadth ().
#incloureutilitzant l'espai de noms std;
classe Rectangle_Class
{
privat:
intllargada;
intamplada;
públic:
Rectangle_Class();
Rectangle_Class(intel,intb);
Rectangle_Class(Rectangle_Class&r);
intgetLength()
{
tornarllargada;
}
intgetBreadth()
{
tornaramplada;
}
buitsetLength(intel);
buitsetBreadth(intb);
intàrea();
};
classe Cube_Class:public Rectangle_Class
{
privat:
intalçada;
públic:
Cube_Class(inth)
{
alçada=h;
}
intgetHeight()
{
tornaralçada;
}
buitsetHeight(inth)
{
alçada=h;
}
intvolum()
{
tornargetLength()*getBreadth()*alçada;
}
};
Rectangle_Class::Rectangle_Class()
{
llargada=1;
amplada=1;
}
Rectangle_Class::Rectangle_Class(intel,intb)
{
llargada=el;
amplada=b;
}
Rectangle_Class::Rectangle_Class(Rectangle_Class&r)
{
llargada=r.llargada;
amplada=r.amplada;
}
buitRectangle_Class::setLength(intel)
{
llargada=el;
}
buitRectangle_Class::setBreadth(intb)
{
amplada=b;
}
intRectangle_Class::àrea()
{
tornarllargada*amplada;
}
intprincipal()
{
Cube_Class c(8);
c.setLength(12);
c.setBreadth(9);
cost<<'El volum és'<<c.volum()<<endl;
}
Conclusió:
En aquest article he explicat el concepte d 'Herència a C ++ . C ++ admet diferents tipus d’herència, inclosa l’herència múltiple (és a dir, heretar funcions de diverses classes base o classe pare). No obstant això, per fer-ho més senzill, aquí només he considerat una herència única. He mostrat tres exemples de treball per explicar com podem utilitzar l'herència en la programació de C ++ i tornar a utilitzar el codi. A més, aquesta és una característica molt útil de C ++.