Herança
Em C++, herança é um dos pilares da programação orientada a objetos (OOP) e permite que classes derivadas reutilizem atributos e métodos de classes base. Isso promove modularidade, manutenção simplificada e organização hierárquica de sistemas complexos. Herança é fundamental para implementar polimorfismo, abstração e para reduzir duplicação de código. Por exemplo, se tivermos uma classe base "Veículo" e classes derivadas "Carro" e "Moto", podemos encapsular propriedades comuns como marca e ano na classe base e deixar atributos específicos, como número de portas ou cilindradas, nas classes derivadas.
O uso da herança é indicado quando múltiplas classes compartilham características comuns ou quando se deseja criar um contrato de interface uniforme. C++ oferece diferentes tipos de herança: public, protected e private, que definem o nível de acesso aos membros da classe base. Neste tutorial, você aprenderá a criar classes base e derivadas, utilizar construtores e destrutores, implementar funções virtuais e polimorfismo, além de aplicar herança em projetos reais de C++ para construir arquiteturas escaláveis e eficientes.
Exemplo Básico
text\#include <iostream>
\#include <string>
class Veiculo {
protected:
std::string marca;
int ano;
public:
Veiculo(const std::string& m, int a) : marca(m), ano(a) {}
virtual void exibir() const {
std::cout << "Marca: " << marca << ", Ano: " << ano << std::endl;
}
virtual \~Veiculo() {}
};
class Carro : public Veiculo {
private:
int portas;
public:
Carro(const std::string& m, int a, int p) : Veiculo(m, a), portas(p) {}
void exibir() const override {
std::cout << "Marca: " << marca << ", Ano: " << ano << ", Portas: " << portas << std::endl;
}
};
int main() {
Veiculo v("Genérico", 2020);
Carro c("Toyota", 2023, 4);
v.exibir();
c.exibir();
Veiculo* ptr = &c;
ptr->exibir(); // Demonstração de polimorfismo
return 0;
}Neste exemplo, a classe Veiculo é a classe base, contendo membros protegidos marca e ano, e a função virtual exibir. A classe derivada Carro herda publicamente de Veiculo e inicializa seus membros com lista de inicialização no construtor. A função exibir é sobrescrita, demonstrando polimorfismo quando um ponteiro da classe base chama o método da classe derivada. O destrutor virtual garante liberação correta de recursos, prevenindo vazamentos de memória. O exemplo evidencia como implementar herança, controle de acesso, construtores e funções virtuais em C++ seguindo boas práticas.
Exemplo Prático
text\#include <iostream>
\#include <vector>
\#include <memory>
class Funcionario {
protected:
std::string nome;
double salario;
public:
Funcionario(const std::string& n, double s) : nome(n), salario(s) {}
virtual void exibir() const {
std::cout << "Funcionário: " << nome << ", Salário: " << salario << std::endl;
}
virtual double calcularBonus() const = 0; // Função pura virtual
virtual \~Funcionario() {}
};
class Gerente : public Funcionario {
private:
int tamanhoEquipe;
public:
Gerente(const std::string& n, double s, int t) : Funcionario(n, s), tamanhoEquipe(t) {}
void exibir() const override {
std::cout << "Gerente: " << nome << ", Salário: " << salario << ", Equipe: " << tamanhoEquipe << std::endl;
}
double calcularBonus() const override {
return salario * 0.1 + tamanhoEquipe * 100;
}
};
class Desenvolvedor : public Funcionario {
private:
std::string linguagem;
public:
Desenvolvedor(const std::string& n, double s, const std::string& l) : Funcionario(n, s), linguagem(l) {}
void exibir() const override {
std::cout << "Desenvolvedor: " << nome << ", Salário: " << salario << ", Linguagem: " << linguagem << std::endl;
}
double calcularBonus() const override {
return salario * 0.15;
}
};
int main() {
std::vector\<std::unique_ptr<Funcionario>> equipe;
equipe.push_back(std::make_unique<Gerente>("Alice", 90000, 5));
equipe.push_back(std::make_unique<Desenvolvedor>("Bob", 80000, "C++"));
for (const auto& f : equipe) {
f->exibir();
std::cout << "Bônus: $" << f->calcularBonus() << std::endl;
}
return 0;
}Neste exemplo, Funcionario é uma classe abstrata com função pura virtual calcularBonus. Gerente e Desenvolvedor herdam de Funcionario, sobrescrevendo exibir e calcularBonus. O uso de std::unique_ptr garante gerenciamento seguro de memória, enquanto std::vector armazena objetos de tipos diferentes. Funções virtuais são chamadas dinamicamente, demonstrando polimorfismo. O exemplo aplica herança, abstração e recursos modernos de C++ para construir arquiteturas escaláveis e seguras em projetos reais.
Boas práticas incluem o uso de destrutores virtuais para liberar recursos, herança pública para relações "is-a", listas de inicialização de construtores e evitar slicing de objetos. É recomendável minimizar profundidade de hierarquias e usar composição quando necessário. Para otimização, utilize containers e algoritmos STL. Para depuração, ferramentas como Valgrind ajudam a detectar vazamentos de memória. A segurança é mantida usando corretamente membros protected/private e evitando ponteiros pendentes.
📊 Tabela de Referência
| C++ Element/Concept | Description | Usage Example |
|---|---|---|
| Classe Base | Classe da qual se herda | class Veiculo { /* membros */ }; |
| Classe Derivada | Classe que herda a base | class Carro : public Veiculo { /* membros */ }; |
| Função Virtual | Pode ser sobrescrita | virtual void exibir() const; |
| Função Pura Virtual | Obrigatória em derivadas | virtual double calcularBonus() const = 0; |
| Polimorfismo | Chamada correta em runtime | Veiculo* ptr = \&c; ptr->exibir(); |
| Lista de Inicialização | Inicializa membros eficientemente | Carro(const std::string& m,int a,int p): Veiculo(m,a), portas(p) {} |
A herança em C++ permite modelar relações entre objetos, reutilizar código e aplicar polimorfismo. Compreender herança permite construir sistemas manuteníveis e extensíveis, gerenciar hierarquias de classes e aplicar princípios avançados de OOP. Próximos passos incluem estudar herança múltipla, classes abstratas e padrões de projeto como Factory e Strategy. Praticar com STL e objetos polimórficos fortalece habilidades de programação avançada em C++.
🧠 Teste Seu Conhecimento
Test Your Knowledge
Test your understanding of this topic with practical questions.
📝 Instruções
- Leia cada pergunta cuidadosamente
- Selecione a melhor resposta para cada pergunta
- Você pode refazer o quiz quantas vezes quiser
- Seu progresso será mostrado no topo