Neste artigo, vamos discutir o conceito de herança na programação C ++. Explicaremos o conceito da função friend em C ++ com exemplos práticos.
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 filha terá todos os recursos da classe pai ou classe base. Podemos reutilizar o código com a ajuda da herança.
Tipo de Herança
Existem diferentes tipos de herança:
- Herança simples / única
- Herança Hierárquica
- Herança multinível
- Herança Múltipla
Neste artigo, vamos considerar apenas a herança simples / única.
Exemplo 1:
Agora, vamos examinar um programa de exemplo para entender o conceito de herança em C ++. Definimos uma classe base e, em seguida, derivamos outra classe dela. Portanto, a classe derivada terá os recursos (membros e funções) da classe base.
#incluirusando namespace std;
classe Base_Class
{
público:
inteu;
vazioexibição()
{
custo<< 'Exibição da Classe Base' <<eu<<endl;
}
};
classe Derived_Class:public Base_Class
{
público:
vazioexposição()
{
custo<< 'Show de Classe Derivada' <<endl;
}
};
inta Principal()
{
Derived_Class dc;
DCeu = 100;
DCexibição();
DCexposição();
Retorna 0;
}
Exemplo 2:
Este é outro exemplo de herança em C ++. Neste exemplo, veremos como os construtores são chamados quando um objeto de classe derivada é criado.
Como você pode ver abaixo, definimos dois construtores de classe base e três construtores de classe derivada. Você pode notar claramente na saída abaixo que o construtor da classe base é chamado primeiro, antes que o construtor da classe derivada seja chamado.
#incluirusando namespace std;
classe Base_Class
{
público:
Base_Class()
{
custo<< 'Base_Class - Sem Parâmetros' <<endl;
}
Base_Class(intx)
{
custo<< 'Base_Class - Parâmetros:' <<x<<endl;
}
};
classe Derived_Class:public Base_Class
{
público:
Classe derivada()
{
custo<< 'Derived_Class - Sem Parâmetros' <<endl;
}
Classe derivada(inte)
{
custo<< 'Derived_Class - Parâmetros:' <<e<<endl;
}
Classe derivada(intx,inte):Base_Class(x)
{
custo<< 'Parâmetro de Derived_Class:' <<e<<endl;
}
};
inta Principal()
{
Derived_Class d(7,19);
}
Exemplo 3:
Neste exemplo, veremos como objetos de classe derivados podem ser usados.
Como você pode ver, existem duas classes definidas: Rectangle_Class e Cube_Class. O Rectangle_Class é a classe base da qual a classe derivada, ou seja, Cube_Class é derivada. Portanto, estamos herdando os recursos de Rectangle_Class para Cube_Class.
Além disso, você pode notar que estamos herdando 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, em seguida, chamamos os métodos da classe base, ou seja, setLength () e setBreadth ().
#incluirusando namespace std;
classe Rectangle_Class
{
privado:
intcomprimento;
intlargura;
público:
Rectangle_Class();
Rectangle_Class(inta,intb);
Rectangle_Class(Rectangle_ClassEr);
intgetLength()
{
Retornacomprimento;
}
intgetBreadth()
{
Retornalargura;
}
vaziosetLength(inta);
vaziosetBreadth(intb);
intárea();
};
classe Cube_Class:public Rectangle_Class
{
privado:
intaltura;
público:
Cube_Class(inth)
{
altura=h;
}
intgetHeight()
{
Retornaaltura;
}
vaziosetHeight(inth)
{
altura=h;
}
intvolume()
{
RetornagetLength()*getBreadth()*altura;
}
};
Rectangle_Class::Rectangle_Class()
{
comprimento=1;
largura=1;
}
Rectangle_Class::Rectangle_Class(inta,intb)
{
comprimento=a;
largura=b;
}
Rectangle_Class::Rectangle_Class(Rectangle_ClassEr)
{
comprimento=r.comprimento;
largura=r.largura;
}
vazioRectangle_Class::setLength(inta)
{
comprimento=a;
}
vazioRectangle_Class::setBreadth(intb)
{
largura=b;
}
intRectangle_Class::área()
{
Retornacomprimento*largura;
}
inta Principal()
{
Cube_Class c(8);
c.setLength(12);
c.setBreadth(9);
custo<<'Volume é'<<c.volume()<<endl;
}
Conclusão:
Neste artigo, expliquei o conceito de herança em C ++ . O C ++ oferece suporte a diferentes tipos de herança, incluindo herança múltipla (ou seja, herdar recursos de classe base múltipla ou classe pai). No entanto, para simplificar, considerei apenas a herança única aqui. Mostrei três exemplos de trabalho para explicar como podemos usar herança na programação C ++ e reutilizar o código. Além disso, esse é um recurso muito útil do C ++.