Herança é um dos quatro pilares da Programação Orientada a Objetos ( OOPs) . É um recurso que permite a uma classe adquirir propriedades e características de outra classe. A herança permite que você reutilize seu código, pois a classe derivada ou a classe filha pode reutilizar os membros da classe base, herdando-os. Considere um exemplo da vida real para entender claramente o conceito de herança. Uma criança herda algumas propriedades de seus pais, como a capacidade de falar, andar, comer e assim por diante. Mas essas propriedades não são herdadas apenas de seus pais. Seus pais herdam essas propriedades de outra classe chamada mamíferos. Essa classe de mamíferos novamente deriva essas características da classe dos animais. A herança funciona da mesma maneira.
Durante a herança, os membros de dados da classe base são copiados na classe derivada e podem ser acessados dependendo do modo de visibilidade usado. A ordem de acessibilidade está sempre em ordem decrescente, ou seja, de pública para protegida. Existem basicamente cinco tipos de herança em C ++ que você explorará neste artigo. Eles são os seguintes:
- Herança única
- Herança múltipla
- Herança multinível
- Herança hierárquica
- Herança híbrida
O que são classes para crianças e pais?
Para entender claramente o conceito de herança, você deve aprender sobre dois termos nos quais todo o conceito de herança é baseado-classe filha e classe pai.
- Classe filha: A classe que herda as características de outra classe é conhecida como classe filha ou classe derivada. O número de classes filhas que podem ser herdadas de uma única classe pai é baseado no tipo de herança. Uma classe filha acessará os membros de dados da classe pai de acordo com o modo de visibilidade especificado durante a declaração da classe filha.
- Classe-mãe: A classe da qual a classe-filha herda suas propriedades é chamada de classe-mãe ou classe-base. Uma única classe pai pode derivar várias classes filhas (Herança hierárquica) ou várias classes pai podem herdar uma única classe base (herança múltipla). Isso depende dos diferentes tipos de herança em C ++.
A sintaxe para definir a classe filha e a classe pai em todos os tipos de herança em C ++ é fornecida abaixo:
classe parent_class
{
//definição de classe da classe pai
};
classe child_class: visibility_mode parent_class
{
//definição de classe da classe filha
};
Descrição da sintaxe
- parent_class: nome da classe base ou da classe pai.
- child_class: nome da classe derivada ou da classe filha.
- visibility_mode: tipo de modo de visibilidade (ou seja, privado, protegido e público) que especifica como os membros de dados da classe filha herdam da classe pai.
Destaque-se de seus colegas esta avaliação Temporada
Comece a aprender com nossos cursos GRATUITOS Inscreva-se agora
Por que e quando usar herança?
A herança torna a programação mais eficiente e é usada devido aos benefícios que oferece. Os usos mais importantes de herança são discutidos abaixo:
- Reutilização de código: um dos principais motivos para usar herança é que você pode reutilizar o código. Por exemplo, considere um grupo de animais como classes separadas-Tigre, Leão e Pantera. Para essas classes, você pode criar funções de membro como predador () porque todos são predadores, canino () porque todos têm dentes caninos para caçar e garras () porque todos os três animais têm garras grandes e afiadas. Agora, como todas as três funções são iguais para essas classes, criar funções separadas para todas elas causará redundância de dados e pode aumentar as chances de erro. Então, em vez disso, você pode usar herança aqui. Você pode criar uma classe base chamada carnívoros e adicionar essas funções a ela e herdar essas funções para as classes tigre, leão e pantera.
- Natureza transitiva: a herança também é usada por causa de sua natureza transitiva. Por exemplo, você tem um mamífero da classe derivada que herda suas propriedades do animal da classe base. Agora, por causa da natureza transitiva da herança, todas as classes filhas de”mamífero”também herdarão as propriedades da classe”animal”. Isso ajuda muito na depuração. Você pode remover os bugs de sua classe base e todas as classes herdadas serão depuradas automaticamente.
Modos de visibilidade
O modo de visibilidade especifica como os recursos da classe base serão herdados pela classe derivada. Existem três tipos de modos de visibilidade para todos os tipos de herança em C ++:
-
Modo de visibilidade pública:
No modo de visibilidade pública, ele mantém a acessibilidade de todos os membros da classe base. Os membros especificados como public, protected e private na classe base permanecem public, protected e private respectivamente na classe derivada. Portanto, os membros públicos são acessíveis pela classe derivada e todas as outras classes. Os membros protegidos são acessíveis apenas dentro da classe derivada e seus membros. No entanto, os membros privados não são acessíveis à classe derivada.
O seguinte snippet de código ilustra como aplicar o modo de visibilidade pública em uma classe derivada:
classe base_class_1
{
//definição de classe
};
classe associated_class: public base_class_1
{
//definição de classe
};
O código a seguir exibe o funcionamento do modo de visibilidade pública com todos os três especificadores de acesso da classe base:
classe base_class
{
privado:
//membro da classe
int base_private;
protegido:
//membro da classe
int base_protected;
público:
//membro da classe
int base_public;
};
classe associated_class: public base_class
{
privado:
int derivado_privado;
//int base_private;
protegido:
int derivado_protegido;
//int base_protected;
público:
int associated_public;
//int base_public;
};
int main ()
{
//Acessando membros da base_class usando o objeto da//classe derivada:
obj de classe derivada;
obj.base_private;//Não acessível
obj.base_protected;//Não acessível
obj.base_public;//Acessível
}
No exemplo acima, a classe derivada herda a classe base como pública. Os membros privados não são acessíveis de forma alguma pela classe derivada. Os membros protegidos são acessíveis apenas dentro da classe derivada e não acessíveis fora da classe. E os membros públicos são acessíveis dentro e fora da classe.
-
Modo de visibilidade privada:
No modo de visibilidade privada, todos os membros da classe base tornam-se privados na classe derivada. Isso restringe o acesso desses membros fora da classe derivada. Eles só podem ser acessados pelas funções de membro da classe derivada. E, neste caso, a classe derivada não herda os membros privados.
O seguinte snippet de código ilustra como aplicar o modo de visibilidade privada em uma classe derivada:
classe base_class_1
{
//definição de classe
};
classe associated_class: private base_class_1
{
//definição de classe
};
O código a seguir exibe o funcionamento do modo de visibilidade privada com todos os três especificadores de acesso da classe base:
classe base_class
{
privado:
//membro da classe
int base_private;
protegido:
//membro da classe
int base_protected;
público:
//membro da classe
int base_public;
};
classe associated_class: private base_class
{
privado:
int derivado_privado;
//int base_private;
//int base_protected;
//int base_public
protegido:
int derivado_protegido;
público:
int associated_public;
};
int main ()
{
//Acessando membros de base_class usando o objeto da classe derivada:
obj de classe derivada;
obj.base_private;//Não acessível
obj.base_protected;//Não acessível
obj.base_public;//Não acessível
}
No exemplo acima, a classe derivada herda a classe base em particular. Portanto, todos os membros da classe base se tornaram privados na classe derivada. O erro é gerado quando o objeto da classe derivada tenta acessar esses membros fora da classe.
-
Modo de visibilidade protegida:
No modo de visibilidade protegido, todos os membros da classe base tornam-se membros protegidos da classe derivada. Esses membros agora estão acessíveis apenas pela classe derivada e suas funções de membro. Esses membros também podem ser herdados e estarão acessíveis às subclasses herdadas. No entanto, os objetos das classes derivadas não podem acessar esses membros fora da classe.
O seguinte snippet de código ilustra como aplicar o modo de visibilidade protegido em uma classe derivada:
classe base_class_1
{
//definição de classe
};
classe derivada_classe: protegida base_class_1
{
//definição de classe
};
O código a seguir exibe o funcionamento do modo de visibilidade protegido com todos os três especificadores de acesso da classe base:
classe base_class
{
privado:
//membro da classe
int base_private;
protegido:
//membro da classe
int base_protected;
público:
//membro da classe
int base_public;
};
classe derivada_classe: base_classe protegida
{
privado:
int derivado_privado;
//int base_private;
protegido:
int derivado_protegido;
//int base_protected;
//int base_public
público:
int associated_public;
};
int main ()
{
//Acessando membros de base_class usando o objeto da classe derivada:
obj de classe derivada;
obj.base_private;//Não acessível
obj.base_protected;//Não acessível
obj.base_public;//Não acessível
}
No exemplo acima, a classe derivada herda a classe base no modo protegido. Todos os membros da classe base agora estão acessíveis apenas dentro da classe derivada e não em qualquer lugar fora da classe. Portanto, ocorre um erro quando o objeto obj da classe derivada tenta acessar esses membros fora da classe.
A tabela a seguir ilustra o controle das classes derivadas sobre os membros da classe base em diferentes modos de visibilidade:
CLASSE BASE |
CLASSE DERIVADA |
CLASSE DERIVADA |
CLASSE DERIVADA |
PÚBLICO |
PROTEGIDO |
PRIVADO |
|
|
PÚBLICO |
Público |
Protegido |
Privado |
|
PROTEGIDO |
Protegido |
Protegido |
Privado |
|
PRIVADO |
Não herdado/permanece privado |
Não herdado/permanece privado |
Não herdado/permanece privado |
Tipos de herança em C ++
Existem cinco tipos de herança em C ++ com base em como a classe derivada herda seus recursos da classe base. Esses cinco tipos são os seguintes:
-
Herança única
A herança única é a mais primitiva entre todos os tipos de herança em C ++. Nessa herança, uma única classe herda as propriedades de uma classe base. Todos os membros de dados da classe base são acessados pela classe derivada de acordo com o modo de visibilidade (ou seja, privado, protegido e público) que é especificado durante a herança.
Sintaxe
classe base_class_1
{
//definição de classe
};
classe associated_class: visibility_mode base_class_1
{
//definição de classe
};
Descrição
Uma única classe derivada herda uma única classe base. O visible_mode é especificado ao declarar a classe derivada para especificar o controle dos membros da classe base dentro da classe derivada.
Exemplo
O exemplo a seguir ilustra a herança única em C ++:
#include
usando namespace std;
//classe base
class electronicDevice
{
público:
//construtor da classe base
electronicDevice ()
{
cout <<"Sou um dispositivo eletrônico. \ n \ n";
}
};
//classe derivada
class Computer: public electronicDevice
{
público:
//construtor da classe derivada
Computador ()
{
cout <<"Sou um computador. \ n \ n";
}
};
int main ()
{
//cria o objeto da classe derivada
Objeto de computador;//construtor da classe base e
//a classe derivada será chamada
return 0;
}
No exemplo acima, a subclasse Computer herda a classe base electronicDevice em modo público. Portanto, todas as funções de membro públicas e protegidas e membros de dados da classe electronicDevice são diretamente acessíveis à classe Computer. Como há uma única classe derivada herdando uma única classe base, isso é Herança Única.
-
Herança múltipla
A herança na qual uma classe pode herdar ou derivar as características de várias classes, ou uma classe derivada pode ter mais de uma classe base, é conhecida como Herança Múltipla. Ele especifica especificadores de acesso separadamente para todas as classes básicas no momento da herança. A classe derivada pode derivar os recursos conjuntos de todas essas classes e os membros de dados de todas as classes base são acessados pela classe derivada ou filha de acordo com os especificadores de acesso.
Sintaxe
classe base_class_1
{
//definição de classe
};
classe base_class_2
{
//definição de classe
};
classe associated_class: visibility_mode_1 base_class_1, visibility_mode_2 base_class_2
{
//definição de classe
};
Descrição
A derivada_classe herda as características de duas classes base, base_class_1 e base_class_2. O visible_mode é especificado para cada classe base ao declarar uma classe derivada. Esses modos podem ser diferentes para cada classe base.
Exemplo
O exemplo a seguir ilustra a herança múltipla em C ++:
#include
usando namespace std;
//class_A
class electronicDevice
{
público:
//construtor da classe base 1
electronicDevice ()
{
cout <<"Sou um dispositivo eletrônico. \ n \ n";
}
};
//class_B
classe Computador
{
público:
//construtor da classe base 2
Computador ()
{
cout <<"Sou um computador. \ n \ n";
}
};
//class_C herdando class_A e class_B
class Linux_based: public electronicDevice, public Computer
{};
int main ()
{
//cria o objeto da classe derivada
obj baseado em Linux;//construtor da classe base A,
//classe base B e classe derivada
//será chamado
return 0;
}
No exemplo acima, existem classes base separadas, electronicDevice e Computer. A classe derivada Linux_based herda ambas as classes formando uma estrutura de herança múltipla. A classe derivada Linux_based herdou os atributos de ambas as classes básicas no modo público. Quando você cria um objeto da classe derivada, ele chama o construtor de ambas as classes base.
-
Herança multinível
A herança na qual uma classe pode ser derivada de outra classe derivada é conhecida como Herança multinível. Suponha que haja três classes A, B e C. A é a classe base que deriva da classe B. Portanto, B é a classe derivada de A. Agora, C é a classe que deriva da classe B. Isso torna a classe B , a classe base para a classe C, mas é a classe derivada da classe A. Este cenário é conhecido como Herança multinível. Os membros de dados de cada classe base respectiva são acessados por suas respectivas classes derivadas de acordo com os modos de visibilidade especificados.
Sintaxe
classe class_A
{
//definição de classe
};
classe class_B: visibility_mode class_A
{
//definição de classe
};
classe class_C: visibility_mode class_B
{
//definição de classe
};
Descrição
A classe_A é herdada pela subclasse class_B. A class_B é herdada pela subclasse class_C. Uma subclasse herda uma única classe em cada nível seguinte.
Exemplo
O exemplo a seguir ilustra a herança multinível em C ++:
#include
usando namespace std;
//class_A
class electronicDevice
{
público:
//construtor da classe base 1
electronicDevice ()
{
cout <<"Sou um dispositivo eletrônico. \ n \ n";
}
};
//class_B herdando class_A
class Computer: public electronicDevice
{
público:
//construtor da classe base 2
Computador ()
{
cout <<"Sou um computador. \ n \ n";
}
};
//class_C herdando classe_B
classe Linux_based: public Computer
{
público:
//construtor da classe derivada
Baseado em Linux ()
{
cout <<"Eu corro no Linux. \ n \ n";;
}
};
int main ()
{
//cria o objeto da classe derivada
obj baseado em Linux;//construtor da classe base 1,
//classe base 2, a classe derivada será chamada
return 0;
}
No exemplo acima, a classe base electronicDevice é herdada pela subclasse Computer que é posteriormente herdada pela subclasse Linux_based. Como uma classe é herdada por uma única classe em cada nível, ela é Herança de vários níveis. O objeto da classe derivada Linux_based pode acessar os membros da classe electronicDevice e Computer diretamente.
-
Herança hierárquica
A herança na qual uma única classe base herda várias classes derivadas é conhecida como Herança hierárquica. Essa herança tem uma estrutura semelhante a uma árvore, pois cada classe atua como uma classe base para uma ou mais classes filhas. O modo de visibilidade para cada classe derivada é especificado separadamente durante a herança e acessa os membros de dados de acordo.
Sintaxe
classe class_A
{
//definição de classe
};
classe class_B: visibility_mode class_A
{
//definição de classe
};
classe class_C: visibility_mode class_A
{
//definição de classe
};
classe class_D: visibility_mode class_B
{
//definição de classe
};
classe class_E: visibility_mode class_C
{
//definição de classe
};
Descrição
As subclasses class_B e class_C herdam os atributos da classe base class_A. Além disso, essas duas subclasses são herdadas por outras subclasses class_D e class_E, respectivamente.
Exemplo
O exemplo a seguir ilustra a Herança hierárquica em C ++:
#include
usando namespace std;
//classe base
class electronicDevice
{
público:
//construtor da classe base 1
electronicDevice ()
{
cout <<"Sou um dispositivo eletrônico. \ n \ n";
}
};
//classe derivada herdando classe base
class Computer: public electronicDevice
{};
//classe derivada herdando classe base
classe Linux_based: public electronicDevice
{};
int main ()
{
//cria o objeto das classes derivadas
Computer obj1;//construtor da classe base será chamado
obj2 baseado em Linux;//construtor da classe base será chamado
return 0;
}
No exemplo acima, a classe base electronicDevice é herdada por duas subclasses Computer e Linux_based. A estrutura da classe representa a herança hierárquica. Ambas as classes derivadas podem acessar os membros públicos da classe base electronicDevice. Quando ele cria objetos dessas duas classes derivadas, ele chama o construtor da classe base para ambos os objetos.
-
Herança híbrida
Herança híbrida, como o nome sugere, é a combinação de dois ou mais de dois tipos de heranças. Por exemplo, as classes em um programa estão em tal disposição que mostram herança única e herança hierárquica ao mesmo tempo. Tal arranjo é conhecido como Herança Híbrida. Esta é sem dúvida a herança mais complexa entre todos os tipos de herança em C ++. Os membros de dados da classe base serão acessados de acordo com o modo de visibilidade especificado.
Sintaxe
classe class_A
{
//definição de classe
};
classe class_B
{
//definição de classe
};
classe classe_C: visibilidade_modo classe_A, visibilidade_modo classe_B
{
//definição de classe
};
classe class_D: visibility_mode class_C
{
//definição de classe
};
classe class_E: visibility_mode class_C
{
//definição de classe
};
Descrição
A classe derivada class_C herda duas classes básicas que são, class_A e class_B. Esta é a estrutura da Herança Múltipla. E duas subclasses class_D e class_E, herdam ainda class_C. Esta é a estrutura da Herança hierárquica. A estrutura geral da Herança Híbrida inclui mais de um tipo de herança.
Exemplo
O exemplo a seguir ilustra a herança híbrida em C ++:
#include
usando namespace std;
//classe base 1
class electronicDevice
{
público:
//construtor da classe base 1
electronicDevice ()
{
cout <<"Sou um dispositivo eletrônico. \ n \ n";
}
};
//classe base 2
classe Computador
{
público:
//construtor da classe base 2
Computador ()
{
cout <<"Sou um computador. \ n \ n";
}
};
//classe derivada 1 herdando a classe base 1 e a classe base 2
class Linux_based: public electronicDevice, public Computer
{};
//classe derivada 2 herdando classe derivada 1
classe Debian: baseado em Linux público
{};
int
principal ()
{
//cria um objeto da classe derivada
Debian obj;//construtor de classes base e
//a classe derivada será chamada
return 0;
}
No exemplo acima, as três classes electronicDevice, Computer e Linux_based formam a estrutura de Multiple Inheritance. E a classe Debian herda a classe Linux_base formando a estrutura de Herança Única. Quando um objeto da classe derivada Debian é criado, os construtores de todas as suas superclasses são chamados.
Curso Full Stack Web Developer
Para se tornar um especialista em MEAN Stack Ver Curso
Problema do diamante
O problema do diamante na herança ocorre quando há uma classe derivada herdando os atributos de 2 superclasses, e essas superclasses têm uma classe base comum. O diagrama a seguir representa a estrutura de um problema de diamante.
Em um problema de diamante, quando as duas classes class_1 e class_2 herdam a mesma classe base, ele cria duas cópias da Base_class. Portanto, quando um objeto da classe derivada acessa um membro da classe base, isso causa ambigüidade. Essa situação ambígua é causada porque não está claro qual cópia do membro base_class precisa ser acessada. E, em tal situação, o compilador gera um erro.
O exemplo a seguir ilustra a situação ambígua causada por uma herança estruturada em diamante.
#include
usando namespace std;
//classe base
classe Base_class
{
público:
int x;
};
//classe 1
classe class_1: public Base_class
{
público:
int y;
};
//classe 2
classe class_2: public Base_class
{
público:
int z;
};
//classe derivada 3
classe derivada_classe: public class_1, public class_2
{
público:
soma total;
};
int main ()
{
//crie um objeto da classe derivada
obj de classe derivada;
obj.x=10;//ambíguo
obj.y=20;
obj.z=30;
obj.sum=obj.x + obj.y + obj.z;
cout <<"A soma é:"< return 0; } No exemplo acima, ele gera um erro por causa da ambigüidade causada. Isso acontece porque há duas cópias do membro de dados “x” da base_class, uma para class_1 e outra para class_2. Quando o objeto “obj” da classe derivada tenta acessar esta variável membro, não é especificado qual cópia da variável “x” deve ser usada. Existem duas maneiras de evitar a situação ambígua em um problema de diamante. O exemplo a seguir ilustra o funcionamento do operador de resolução do escopo para remover a ambigüidade no problema do diamante. #include usando namespace std; //classe base classe Base_class { público: int x; }; //classe 1 classe class_1: public Base_class { público: int y; }; //classe 2 classe class_2: public Base_class { público: int z; }; //classe derivada 3 classe derivada_classe: public class_1, public class_2 { público: soma total; }; int main () { //crie um objeto da classe derivada obj de classe derivada; obj.class_1:: x=10;//agora é inequívoco obj.y=20; obj.z=30; obj.sum=obj.class_1:: x + obj.y + obj.z; cout <<"A soma é:"< return 0; } In the above example, the following expression uses the scope resolution operator to specify which copy of “x” is to be used. obj.class_1::x; Here, the class_1’s version of “x” is accessed. In this case, no error is thrown as the ambiguous statement has been resolved to become unambiguous. Although the scope resolution operator removes the ambiguity and produces correct output, there are still two copies of the base class. If you require only one copy of the base class, then there is the virtual keyword for this. The virtual keyword allows only one copy of the base class to be created, and the object of the derived class can access the members of the base class in the usual way. The following example illustrates the working of the virtual keyword to remove ambiguity in the diamond problem. #include usando namespace std; //base class class Base_class { public: int x; }; //class 1 class class_1: virtual public Base_class { public: int y; }; //class 2 class class_2: virtual public Base_class { public: int z; }; //derived class 3 class derived_class: public class_1, public class_2 { public: int sum; }; int main () { //create an object of the derived_class derived_class obj; obj.x=10; //it is now unambiguous obj.y=20; obj.z=30; obj.sum=obj.x + obj.y + obj.z; cout <<"The sum is:"< return 0; } In the above example, two classes class_1 and class_2 inherit the base class as virtual. Any Multiple Inheritance involving these subclasses creates only a single copy of the base_class. So, now the derived_class has only one copy of the base_class, which makes the following statement valid and unambiguous. obj.x=10; In inheritance, the private members of a base class are not inherited by the derived classes. So these members of the base class are not accessible to the objects of the derived class. Only the public and the protected members are inherited and can be accessed by the derived classes. The private members of the base class can be made inheritable in two ways: Making the access modifier of the private member public makes it inheritable by the derived classes. However, a problem arises with this approach. The data hiding property is no longer there for that member as it is now accessible to all other functions of the program. This approach retains the data hiding property of the private member. Modifying the access specifier of a private member as protected, makes it inheritable and accessible by the derived class. If these members are required to be inheritable further beyond the immediately derived class, then they should be inherited as public. Otherwise, they should be inherited as private which will end the inheritance hierarchy beyond the immediately derived class. Avance sua carreira como desenvolvedor MEAN stack com o Desenvolvedor Web Full Stack-Programa MEAN Stack Master . Inscreva-se agora! In this comprehensive guide on the types of inheritance in C++, you started with a brief introduction to C++ and the concept of parent and child classes. You understood why and when to use which types of inheritance in C++ along with the different visibility modes that can be used with the classes and members. You understood the five different types of inheritance, their use-cases, examples, and the fundamental differences between them. You looked at a very common problem that arises due to multiple inheritances called the diamond problem and the solution to it. Finally, you saw how to make a private member inheritable. If you want to learn more about such concepts of C++ with examples, you can check out our guide on C++ for beginners. If you want to land your foot in Full Stack Web Development, you should check out Simplilearn’s comprehensive training program on Full Stack Web Development. This program will help you to learn top technical skills like DevOps, Agile, HTML, CSS, Servlets, JS, Java, and its libraries such as Spring, Hibernate, JPA, etc. This course is led by top industry experts and they are available throughout the course to help you solve your queries. You can also check out our complete list of free online courses. If you have any queries related to our article on “Types of inheritance in C++” or any other suggestion, please feel free to drop a comment on the comment box. Our experts will get back to you as soon as possible. Happy Learning!
How to Make a Private Member Inheritable?
Modifying the Visibility Mode From Private to Public.
Modifying the Visibility Mode From Private to Protected.
Considerações finais!
