Herança C++
Herança C++
Neste tutorial, aprenderemos sobre herança em C++ com a ajuda de exemplos.
A herança é um dos principais recursos da programação orientada a objetos em C++. Ele nos permite criar uma nova classe (classe derivada) a partir de uma classe existente (classe base).
A classe derivada herda os recursos da classe base e pode ter recursos adicionais próprios. Por exemplo,
class Animal {
// eat() function
// sleep() function
};
class Dog : public Animal {
// bark() function
}; Aqui, o
Dog classe é derivada do Animal classe. Desde Dog é derivado de Animal , membros de Animal são acessíveis a Dog . 
Observe o uso da palavra-chave
public ao herdar Cão de Animal.
class Dog : public Animal {...}; Também podemos usar as palavras-chave
private e protected em vez de public . Aprenderemos sobre as diferenças entre usar private , public e protected posteriormente neste tutorial. é-um relacionamento
A herança é um relacionamento é-um . Usamos herança apenas se um relacionamento é um está presente entre as duas classes.
aqui estão alguns exemplos:
- Um carro é um veículo.
- Laranja é uma fruta.
- Um cirurgião é um médico.
- Um cachorro é um animal.
Exemplo 1:Exemplo simples de herança C++
// C++ program to demonstrate inheritance
#include <iostream>
using namespace std;
// base class
class Animal {
public:
void eat() {
cout << "I can eat!" << endl;
}
void sleep() {
cout << "I can sleep!" << endl;
}
};
// derived class
class Dog : public Animal {
public:
void bark() {
cout << "I can bark! Woof woof!!" << endl;
}
};
int main() {
// Create object of the Dog class
Dog dog1;
// Calling members of the base class
dog1.eat();
dog1.sleep();
// Calling member of the derived class
dog1.bark();
return 0;
} Saída
I can eat! I can sleep! I can bark! Woof woof!!
Aqui, cão1 (o objeto da classe derivada
Dog ) pode acessar membros da classe base Animal . É porque Dog é herdado de Animal .
// Calling members of the Animal class
dog1.eat();
dog1.sleep(); Membros protegidos por C++
O modificador de acesso
protected é especialmente relevante quando se trata de herança C++. Curtir
private membros, protected membros são inacessíveis fora da classe. No entanto, eles podem ser acessados por classes derivadas e classes/funções de amigos . Precisamos de
protected membros se quisermos ocultar os dados de uma classe, mas ainda queremos que esses dados sejam herdados por suas classes derivadas. Para saber mais sobre protegido, consulte nosso tutorial sobre modificadores de acesso C++.
Exemplo 2:Membros protegidos por C++
// C++ program to demonstrate protected members
#include <iostream>
#include <string>
using namespace std;
// base class
class Animal {
private:
string color;
protected:
string type;
public:
void eat() {
cout << "I can eat!" << endl;
}
void sleep() {
cout << "I can sleep!" << endl;
}
void setColor(string clr) {
color = clr;
}
string getColor() {
return color;
}
};
// derived class
class Dog : public Animal {
public:
void setType(string tp) {
type = tp;
}
void displayInfo(string c) {
cout << "I am a " << type << endl;
cout << "My color is " << c << endl;
}
void bark() {
cout << "I can bark! Woof woof!!" << endl;
}
};
int main() {
// Create object of the Dog class
Dog dog1;
// Calling members of the base class
dog1.eat();
dog1.sleep();
dog1.setColor("black");
// Calling member of the derived class
dog1.bark();
dog1.setType("mammal");
// Using getColor() of dog1 as argument
// getColor() returns string data
dog1.displayInfo(dog1.getColor());
return 0;
} Saída
I can eat! I can sleep! I can bark! Woof woof!! I am a mammal My color is black
Aqui, a variável tipo é
protected e, portanto, é acessível a partir da classe derivada Dog . Podemos ver isso quando inicializamos type no Dog classe usando a função setType() . Por outro lado, o
private variável cor não pode ser inicializado em Dog .
class Dog : public Animal {
public:
void setColor(string clr) {
// Error: member "Animal::color" is inaccessible
color = clr;
}
}; Além disso, como o
protected palavra-chave oculta dados, não podemos acessar tipo diretamente de um objeto de Dog ou Animal classe.
// Error: member "Animal::type" is inaccessible
dog1.type = "mammal"; Modos de acesso na herança C++
Em nossos tutoriais anteriores, aprendemos sobre especificadores de acesso C++, como público, privado e protegido.
Até agora, usamos o
public palavra-chave para herdar uma classe de uma classe base já existente. No entanto, também podemos usar o private e protected palavras-chave para herdar classes. Por exemplo,
class Animal {
// code
};
class Dog : private Animal {
// code
};
class Cat : protected Animal {
// code
}; As várias maneiras de derivar classes são conhecidas como modos de acesso . Esses modos de acesso têm o seguinte efeito:
- público: Se uma classe derivada for declarada em
publicmode, então os membros da classe base são herdados pela classe derivada exatamente como estão. - privado: Nesse caso, todos os membros da classe base se tornam
privatemembros na classe derivada. - protegido: O
publicmembros da classe base se tornamprotectedmembros na classe derivada.
O
private membros da classe base são sempre private na classe derivada. Para saber mais, visite nosso tutorial de herança pública, privada e protegida de C++.
Substituição de função de membro na herança
Suponha que a classe base e a classe derivada tenham funções-membro com o mesmo nome e argumentos.
Se criarmos um objeto da classe derivada e tentarmos acessar essa função-membro, a função-membro da classe derivada será invocada em vez da da classe base.
A função membro da classe derivada substitui a função membro da classe base.
Saiba mais sobre substituição de função em C++.
Leitura recomendada: Herança múltipla de C++
Linguagem C