Herança em C

Herança em C é um dos pontos chave de programação orientada a objetos (POO). Ela fornece meios de promover a extensibilidade do código, a reutilização e uma maior coerência lógica no modelo de implementação.

Estas características nos possibilitam diversas vantagens, principalmente quando o mantemos bibliotecas para uso futuro de determinados recursos que usamos com muita frequência.

Uma classe de objetos “veiculo”, por exemplo, contém todas as características inerentes aos veículos, como: combustível, autonomia, velocidade máxima, etc. Agora podemos dizer que “carro” é uma classe que têm as características básicas da classe “veículo” mais as suas características particulares.

Analisando esse fato, podemos concluir que poderíamos apenas definir em “carro” suas características e usar “veículo” de alguma forma que pudéssemos lidar com as características básicas. Este meio chama-se herança.

Agora podemos definir outros tipos de veículos como: moto, caminhão, trator, helicóptero, etc, sem ter que reescrever a parte que está na classe “veículo”. Para isso define-se a classe “veículo” com suas características e depois cria-se classes específicas para cada veículo em particular, declarando-se o parentesco neste instante.

Outro exemplo: Imagine que já exista uma classe que defina o comportamento de um dado objeto da vida real, por exemplo, animal.

Uma vez que eu sei que o leão é um animal, o que se deve fazer é aproveitar a classe animal e fazer com que a classe leão derive (herde) da classe animal as características e comportamentos que a mesma deve apresentar, que são próprios dos indivíduos classificados como animais.

Ou seja, herança acontece quando duas classes são próximas, têm características mútuas mas não são iguais e existe uma especificação de uma delas.

Portanto, em vez de escrever todo o código novamente é possível poupar algum tempo e dizer que uma classe herda da outra e depois basta escrever o código para a especificação dos pontos necessários da classe derivada (classe que herdou).

Sintaxe:

class classe_derivada : [<acesso>] classe_base {

  //corpo da classe derivada
}

Repare que temos o operador “:” ( dois pontos ) como elo entre as duas classes. Este operador promove o “parentesco” entre as duas classes quando é usado na declaração de uma classe derivada.

O termo [<acesso>] é opcional, mas se estiver presente deve ser public, private ou protected. Ele define o grau de visibilidade dos membros da classe base quando a classe derivada precisar acessá-los.

Exemplo de implementação:

// Demonstra herança
#include <iostream>

using namespace std;
    
class veiculo_rodoviario { // Define uma classe base veículos 
	
int rodas;
int passageiros;

public:
  void set_rodas(int num) { rodas = num; }
  int get_rodas() { return rodas; }

void set_pass(int num) { passageiros = num; }
	int get_pass() { return passageiros; }
};
	
class caminhao : public veiculo_rodoviario { // Define um caminhao
	
  int carga;
  
  public:
	 void set_carga(int size) { carga = size; }
	 int get_carga() { return carga; }
	 void mostrar();
  };
    
 enum tipo {car, van, vagao};
    
 class automovel : public veiculo_rodoviario { // Define um automovel
	
   enum tipo car_tipo;
        
   public:
	 void set_tipo(tipo t) { car_tipo = t; }
	 enum tipo get_tipo() { return car_tipo; }
	 oid mostrar();
   };
    
 void caminhao::mostrar() {
   cout << "rodas: " << get_rodas() << "\n";
   cout << "passageiros: " << get_pass() << "\n";
   cout << "carga (capacidade em litros): " << carga << "\n";
 }

 void automovel::mostrar() {
   cout << "rodas: " << get_rodas() << "\n";
   cout << "passageiros: " << get_pass() << "\n";
   cout << "tipo: ";
        
   switch(get_tipo()) {
		
	 case van: cout << "van\n";
	 break;
	 case car: cout << "carro\n";
	 break;
	 case vagao: cout << "vagao\n";
    }
 }
    
 int main() {
	
  caminhao t1, t2;
  automovel c;
  t1.set_rodas(18);
  t1.set_pass(2);
  t1.set_carga(3200);
  t2.set_rodas(6);
  t2.set_pass(3);
  t2.set_carga(1200);
  t1.mostrar();
  cout << "\n";
  t2.mostrar();
  cout << "\n";
  c.set_rodas(4);
  c.set_pass(6);
  c.set_tipo(van);
  c.mostrar();
        
  #ifdef WIN32
    system ("pause");
  #endif
    
  return 0;
 }

Estruturas de decisão e iteração em C

Dúvidas ou sugestões? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
https://youtube.com/criandobits

Tags: heranca