Herança de C ++

A herança é uma característica muito importante da programação orientada a objetos. Ele permite que o programador deriva uma classe de uma classe existente. Isso é muito útil, especialmente em um grande projeto complexo, porque permite ao programador reutilizar o código.

Neste artigo, discutiremos o conceito de herança na programação C ++. Explicaremos o conceito de função de amigo em C ++ com exemplos de trabalho.

Por que herança?

A herança permite criar uma nova classe ou classe derivada de outra classe ou classe base. A classe derivada ou a classe infantil terão todos os recursos da classe pai ou da classe base. Podemos reutilizar o código com a ajuda da herança.

Tipo de herança

Existem diferentes tipos de herança:

1. Herança simples/única
2. Herança hierárquica
3. Herança multinível
4. Herança múltipla

Neste artigo, vamos considerar apenas herança simples/única.

Exemplo 1:

Agora, vamos analisar um programa de exemplo para entender o conceito de herança em c++. Definimos uma classe base e depois derivamos outra classe dela. Portanto, a classe derivada terá os recursos (membros e funções) da classe base.

#incluir
usando namespace std;
classe base_class

público:
int i;
Void Display ()

cout << "Display of Base Class " << i << endl;

;
Classe derivada_class: public base_class

público:
Void Show ()

cout << "Show of Derived Class" << endl;

;
int main ()

Derivado_class cc;
DC.i = 100;
DC.mostrar();
DC.mostrar();
retornar 0;

Exemplo 2:

Este é outro exemplo de herança em c++. Neste exemplo, vamos ver como os construtores são chamados quando um objeto de classe derivado é criado.

Como você pode ver abaixo, definimos dois construtores de classe base e três construtores de classe derivados. Você pode notar claramente na saída abaixo que o construtor de classe base é chamado primeiro antes que o construtor de classe derivado seja chamado.

#incluir
usando namespace std;
classe base_class

público:
Base_class ()

cout << "Base_Class - No Parameters" << endl;

Base_class (int x)

cout << "Base_Class - Parameters : " << x << endl;

;
Classe derivada_class: public base_class

público:
Classe derivada()

cout << "Derived_Class - No Parameters" << endl;

Derivado_class (int y)

cout << "Derived_Class - Parameters : " << y << endl;

Derivado_class (int x, int y): base_class (x)

cout << "Param of Derived_Class : " << y << endl;

;
int main ()

Derivado_class D (7,19);

Exemplo 3:

Neste exemplo, vamos ver como os objetos de classe derivados podem ser usados.

Como você pode ver, existem duas classes definidas: Rectangle_class e Cube_class. O retângulo_class é a classe base da qual a classe derivada, eu.e., Cube_class é derivado. Portanto, estamos herdando os recursos do Rectangle_class para Cube_class.

Além disso, você pode notar que estamos herdando o Cube_class com o controle de acesso público. Isso significa que a classe derivada pode acessar todos os membros não privados da classe base.

Declaramos um objeto da classe derivada e depois chamamos os métodos da classe base, eu.e., setLength () e setbreadth ().

#incluir
usando namespace std;
Classe Rectangle_class

privado:
comprimento int;
int largura;
público:
Retangle_class ();
Retangle_class (int l, int b);
Retangle_class (retângulo_class & r);
int getLength ()

comprimento de retorno;

int getbreadth ()

retornar amplitude;

Void SetLength (int l);
Void Setbreadth (int b);
int area ();
;
CLASS CUBE_CLASS: Public Rectangle_class

privado:
int altura;
público:
Cube_class (int h)

altura = h;

int getHeight ()

altura de retorno;

Void Sethight (int h)

altura = h;

int volume ()

return getLength ()*getBreadth ()*altura;

;
Retangle_class :: retangn_class ()

comprimento = 1;
largura = 1;

Rettangle_class :: Rectangle_class (int l, int b)

comprimento = l;
largura = b;

Rectangle_class :: Rectangle_class (Rectangle_class & r)

comprimento = r.comprimento;
largura = r.largura;

Void Rectangle_class :: setLength (int l)

comprimento = l;

Void Rectangle_class :: setbreadth (int b)

largura = b;

Int Rectangle_class :: Area ()

comprimento de retorno*largura;

int main ()

Cube_class c (8);
c.SetLength (12);
c.setbreadth (9);
cout<<"Volume is "<

Conclusão:

Neste artigo, expliquei o conceito de herança em c++. O C ++ suporta diferentes tipos de herança, incluindo "herança múltipla" (i.e., herdando recursos de várias classe base ou classe pai). No entanto, para simplificar, eu só considerei a herança única aqui. Eu mostrei três exemplos de trabalho para explicar como podemos usar a herança na programação C ++ e reutilizar o código. Além disso, essa é uma característica muito útil de C++.