A herança é um conceito fundamental na OOP (Programação Orientada a Objetos) . É o mecanismo pelo qual uma classe pode herdar os recursos (campos e métodos) de outra classe. Herança significa criar novas classes com base nas existentes. Uma classe que herda de outra classe pode reutilizar os métodos e campos dessa classe.

Exemplo: No exemplo a seguir Animal é a classe base e Dog Cat e Cow são classes derivadas que estendem a classe Animal.

   #include          using     namespace     std  ;   class     Animal   {      public  :      void     sound  ()      {      cout      < <     'Animal makes a sound'      < <     endl  ;      }   };   class     Dog     :     public     Animal   {      public  :      void     sound  ()      {      cout      < <     'Dog barks'      < <     endl  ;      }   };   class     Cat     :     public     Animal   {      public  :      void     sound  ()      {      cout      < <     'Cat meows'      < <     endl  ;      }   };   class     Cow     :     public     Animal   {      public  :      void     sound  ()      {      cout      < <     'Cow moos'      < <     endl  ;      }   };   int     main  ()   {      Dog     d  ;      d  .  sound  ();      Cat     c  ;      c  .  sound  ();      Cow     cow  ;      cow  .  sound  ();      return     0  ;   }   

Dog barks Cat meows Cow moos  

Explicação:

• Animal é a classe base com uma função sound().
• Dog Cat e Cow são classes derivadas, cada uma definindo seu próprio método sound().
• Em main() os objetos Dog Cat e Cow são criados separadamente.
• Quando chamamos sound() em cada objeto, o respectivo método da classe filha é executado (Cachorro late, Gato mia Vaca muge).

Sintaxe

   class     ChildClass     :     public     ParentClass   {      // Additional fields and methods   };   

Como funciona a herança em C++?

Os dois pontos (:) com um especificador de acesso é usado para herança em C++. Ele permite que a classe derivada (classe filha) herde os membros de dados (campos) e funções de membro (métodos) da classe base (classe pai).
Quando uma classe herda outra classe, ela obtém todos os membros acessíveis da classe pai e a classe filha também pode redefinir (substituir) ou adicionar novas funcionalidades a eles.

Tipos de herança em C++

Abaixo estão os diferentes tipos de herança suportados por C++.

1. Herança única

Na herança única, uma subclasse é derivada de apenas uma superclasse. Ele herda as propriedades e o comportamento de uma classe monoparental. Às vezes também é conhecido como herança simples.

   #include          using     namespace     std  ;   class     Vehicle     {   public  :      Vehicle  ()     {      cout      < <     'This is a Vehicle'      < <     endl  ;      }   };   class     Car     :     public     Vehicle     {   public  :      Car  ()     {      cout      < <     'This Vehicle is Car'      < <     endl  ;      }   };   int     main  ()     {          Car     obj  ;      return     0  ;   }   

This is a Vehicle This Vehicle is Car  

2. Herança Múltipla

Em Herança múltipla uma classe pode ter mais de uma superclasse e herdar recursos de todas as classes pai.

   #include          using     namespace     std  ;   class     LandVehicle   {      public  :      void     landInfo  ()      {      cout      < <     'This is a LandVehicle'      < <     endl  ;      }   };   class     WaterVehicle   {      public  :      void     waterInfo  ()      {      cout      < <     'This is a WaterVehicle'      < <     endl  ;      }   };   // Derived class inheriting from both base classes   class     AmphibiousVehicle     :     public     LandVehicle       public     WaterVehicle   {      public  :      AmphibiousVehicle  ()      {      cout      < <     'This is an AmphibiousVehicle'      < <     endl  ;      }   };   int     main  ()   {      AmphibiousVehicle     obj  ;      obj  .  waterInfo  ();      obj  .  landInfo  ();      return     0  ;   }   

This is an AmphibiousVehicle This is a WaterVehicle This is a LandVehicle  

3. Herança multinível

Herança multinível em C++ significa que uma classe é derivada de outra classe derivada formando uma cadeia de herança.

   #include          using     namespace     std  ;   class     Vehicle   {      public  :      Vehicle  ()      {      cout      < <     'This is a Vehicle'      < <     endl  ;      }   };   // Derived class from Vehicle   class     FourWheeler     :     public     Vehicle   {      public  :      FourWheeler  ()      {      cout      < <     '4 Wheeler Vehicles'      < <     endl  ;      }   };   // Derived class from FourWheeler   class     Car     :     public     FourWheeler   {      public  :      Car  ()      {      cout      < <     'This 4 Wheeler Vehicle is a Car'      < <     endl  ;      }   };   int     main  ()   {      Car     obj  ;      return     0  ;   }   

This is a Vehicle 4 Wheeler Vehicles This 4 Wheeler Vehicle is a Car  

4. Herança Hierárquica

Na herança hierárquica, mais de uma subclasse é herdada de uma única classe base. ou seja, mais de uma classe derivada é criada a partir de uma única classe base. Por exemplo, carros e ônibus são veículos.

   #include          using     namespace     std  ;   class     Vehicle   {      public  :      Vehicle  ()      {      cout      < <     'This is a Vehicle'      < <     endl  ;      }   };   class     Car     :     public     Vehicle   {      public  :      Car  ()      {      cout      < <     'This Vehicle is Car'      < <     endl  ;      }   };   class     Bus     :     public     Vehicle   {      public  :      Bus  ()      {      cout      < <     'This Vehicle is Bus'      < <     endl  ;      }   };   int     main  ()   {      Car     obj1  ;      Bus     obj2  ;      return     0  ;   }   

This is a Vehicle This Vehicle is Car This is a Vehicle This Vehicle is Bus  

5. Herança Híbrida

Quando dois ou mais tipos de herança são combinados em um programa. Por exemplo, uma classe pode usar herança múltipla e também fazer parte de uma cadeia de herança multinível.

   #include          using     namespace     std  ;   class     Vehicle   {      public  :      Vehicle  ()      {      cout      < <     'This is a Vehicle'      < <     endl  ;      }   };   class     Fare   {      public  :      Fare  ()      {      cout      < <     'Fare of Vehicle'      < <     endl  ;      }   };   class     Car     :     public     Vehicle   {      public  :      Car  ()      {      cout      < <     'This Vehical is a Car'      < <     endl  ;      }   };   class     Bus     :     public     Vehicle       public     Fare   {      public  :      Bus  ()      {      cout      < <     'This Vehicle is a Bus with Fare'  ;      }   };   int     main  ()   {      Bus     obj2  ;      return     0  ;   }   

This is a Vehicle Fare of Vehicle This Vehicle is a Bus with Fare 

A herança híbrida pode levar à problema do diamante em C++. Isso acontece quando uma classe herda de duas classes que compartilham a mesma classe base. Como resultado, a classe derivada obtém múltiplas cópias dos membros da classe base, o que cria ambiguidade sobre qual delas usar.

Observação : A solução é usar herança virtual para que apenas uma cópia da classe base seja compartilhada.

Vantagens da herança em C++

• Reutilização de código : A classe derivada pode reutilizar diretamente membros de dados e métodos de sua classe base, evitando duplicação de código.
• Abstração: Suporta classes abstratas (classes com funções virtuais puras) que definem uma interface comum que impõe abstração.
• Hierarquia de classes: Você pode construir hierarquias (base → derivada → derivada adicional) para modelar relacionamentos do mundo real.
• Polimorfismo: Suporta totalmente o polimorfismo de tempo de execução por meio de funções virtuais e também o polimorfismo de tempo de compilação por meio de sobrecarga de funções e modelos.

Desvantagens da herança em C++

• Acoplamento apertado: A classe filha torna-se dependente da classe pai. Qualquer alteração na classe base pode forçar alterações nas classes derivadas.
• Flexibilidade reduzida: Às vezes, a herança é mal utilizada onde a composição (tem um relacionamento) seria melhor, levando a um código menos flexível.
• Maior complexidade: Hierarquias de herança profundas (multinível ou híbridas) podem tornar o código difícil de entender, manter e depurar.
• Problema do diamante: Com herança híbrida ou múltipla, pode ocorrer ambiguidade se a mesma classe base for herdada várias vezes.
• Sobrecarga de funções virtuais: Se o polimorfismo (funções virtuais) for usado, haverá uma pequena sobrecarga de tempo de execução devido às pesquisas em tabelas virtuais.