EASYACM

🧬 Ponteiros para Tipos Derivados

"Em C++, um ponteiro para uma classe base pode apontar para um objeto de uma classe derivada. Essa é a base do polimorfismo e permite escrever código genérico e extensível."

Uma das características mais poderosas da orientação a objetos em C++ é a capacidade de um ponteiro de um tipo base referenciar objetos de tipos derivados. Isso, combinado com funções virtuais, permite o polimorfismo — a habilidade de objetos diferentes responderem à mesma mensagem de formas distintas.

📌 Upcasting: Ponteiro de Base para Derivada

Upcasting é a conversão implícita de um ponteiro de classe derivada para um ponteiro de classe base. É sempre seguro e não requer cast explícito.

class Animal { public: void respirar() { cout << "Animal respirando" << endl; } }; class Cachorro : public Animal { public: void latir() { cout << "Au au!" << endl; } }; int main() { Cachorro* dog = new Cachorro(); Animal* animal = dog; // Upcasting implícito (seguro) animal->respirar(); // OK: Animal tem respirar() // animal->latir(); // ERRO: Animal não tem latir() delete dog; }

🎭 Polimorfismo com Funções Virtuais

Para que o comportamento do objeto derivado seja preservado quando acessado via ponteiro da classe base, os métodos devem ser declarados como virtual.

class Animal { public: virtual void emitirSom() { cout << "Animal faz algum som" << endl; } virtual ~Animal() {} // Destrutor virtual é essencial! }; class Cachorro : public Animal { public: void emitirSom() override { cout << "Au au!" << endl; } }; class Gato : public Animal { public: void emitirSom() override { cout << "Miau!" << endl; } }; int main() { Animal* animais[2]; animais[0] = new Cachorro(); animais[1] = new Gato(); for (int i = 0; i < 2; i++) { animais[i]->emitirSom(); // Polimorfismo! Chama o método correto } for (int i = 0; i < 2; i++) { delete animais[i]; } } // Saída: // Au au! // Miau!

⚠️ Destrutor Virtual é Obrigatório! Se uma classe tem métodos virtuais e será usada como base, declare o destrutor como virtual. Caso contrário, delete em um ponteiro da base pode não chamar o destrutor da derivada, causando vazamento de memória.

📌 Downcasting: Ponteiro de Base para Derivada

Downcasting é a conversão de um ponteiro de classe base para um ponteiro de classe derivada. É potencialmente perigoso e deve ser feito com dynamic_cast para verificação em tempo de execução.

Animal* animal = new Cachorro(); // dynamic_cast retorna nullptr se a conversão for inválida Cachorro* dog = dynamic_cast<Cachorro*>(animal); if (dog != nullptr) { dog->latir(); // Seguro! } Gato* cat = dynamic_cast<Gato*>(animal); if (cat != nullptr) { cat->emitirSom(); // Não executa, pois animal não é Gato } delete animal;

💡 dynamic_cast vs. static_cast:

• dynamic_cast: Verifica o tipo em tempo de execução. Retorna nullptr se inválido (ponteiros) ou lança exceção (referências). Exige hierarquia polimórfica (pelo menos uma função virtual).
• static_cast: Conversão em tempo de compilação. Não verifica tipo. Use apenas quando tiver certeza absoluta do tipo real do objeto.

🧩 Classes Abstratas e Interfaces

Uma classe com pelo menos uma função virtual pura (= 0) é abstrata e não pode ser instanciada. Serve como interface ou base para outras classes.

class Forma { // Classe abstrata (interface) public: virtual double area() const = 0; // Função virtual pura virtual ~Forma() {} }; class Retangulo : public Forma { double largura, altura; public: Retangulo(double l, double a) : largura(l), altura(a) {} double area() const override { return largura * altura; } }; class Circulo : public Forma { double raio; public: Circulo(double r) : raio(r) {} double area() const override { return 3.14159 * raio * raio; } }; int main() { // Forma f; // ERRO: classe abstrata não pode ser instanciada Forma* formas[2]; formas[0] = new Retangulo(5.0, 3.0); formas[1] = new Circulo(2.0); for (int i = 0; i < 2; i++) { cout << "Área: " << formas[i]->area() << endl; delete formas[i]; } }

🔗 Ponteiros e Herança Múltipla

C++ permite herança múltipla. Ponteiros podem ser convertidos entre as diferentes bases, mas atenção com ambiguidades e deslocamentos de ponteiro.

class Animal { public: virtual ~Animal() {} }; class Voador { public: virtual void voar() = 0; }; class Morcego : public Animal, public Voador { public: void voar() override { cout << "Morcego voando" << endl; } }; int main() { Morcego* m = new Morcego(); Animal* a = m; // Upcasting para Animal Voador* v = m; // Upcasting para Voador v->voar(); // OK delete m; }

📊 Tabela de Conversões entre Ponteiros de Classes

Conversão	Mecanismo	Segurança	Quando Usar
Derivada* → Base*	Implícito	🟢 Sempre seguro	Acessar interface comum
Base* → Derivada*	dynamic_cast	🟡 Verificado em execução	Quando não se tem certeza do tipo
Base* → Derivada*	static_cast	🔴 Sem verificação	Apenas com certeza absoluta
Classes não relacionadas	reinterpret_cast	🔴 Muito perigoso	Quase nunca (código de baixo nível)

💡 Boas Práticas com Ponteiros para Derivados

• ✅ Sempre declare destrutores como virtual em classes base polimórficas.
• ✅ Use override em métodos sobrescritos para detectar erros em tempo de compilação.
• ✅ Prefira dynamic_cast para downcasting — é mais seguro e documenta a intenção.
• ✅ Considere usar std::unique_ptr<Base> e std::shared_ptr<Base> para gerenciar objetos derivados com segurança.
• ✅ Evite herança múltipla a menos que seja realmente necessário; prefira interfaces (classes abstratas).

🔗 Conclusão

Ponteiros para tipos derivados são a espinha dorsal do polimorfismo em C++. Eles permitem escrever código flexível que trabalha com interfaces comuns enquanto executa comportamentos específicos de cada tipo. Combinados com funções virtuais e alocação dinâmica, formam a base para frameworks, bibliotecas e padrões de design poderosos.

📘 Capítulo 16 · Ponteiros para Tipos Derivados — Herança e Polimorfismo

⏭️ Próximo: Ponteiros e arrays...