Dominando Funções Virtuais em C++: Conceitos, Exemplos e a Palavra-chave Override

Funções Virtuais em C++

Este tutorial explica funções virtuais em C++, seu propósito e uso prático ilustrado com exemplos de código.

Uma função virtual é um membro da classe base que esperamos que classes derivadas sobrescrevam. Declarar uma função como virtual garante que a implementação mais derivada seja invocada, mesmo quando acessada através de um ponteiro ou referência da classe base.

Quando uma classe base contém um membro não virtual, chamar esse membro via ponteiro base sempre executará a versão da base, independentemente do tipo real do objeto. Considere o seguinte:

class Base { public: void print() { // implementação base } }; class Derived : public Base { public: void print() { // implementação derivada } }; 

No programa abaixo, um Base* aponta para uma instância Derived, ainda assim print() resolve para a versão da base:

int main() { Derived derived1; Base* base1 = &derived1; base1->print(); // chama Base::print() return 0; } 

Para obter comportamento polimórfico, declare a função como virtual na classe base:

class Base { public: virtual void print() { // implementação base } }; 

Funções virtuais são centrais para o polimorfismo em C++. Para um mergulho mais profundo, veja nosso guia de Polimorfismo em C++.

---

Exemplo 1: Uso Básico de Função Virtual

#include <iostream> using namespace std; class Base { public: virtual void print() { cout << "Função Base" << endl; } }; class Derived : public Base { public: void print() override { cout << "Função Derivada" << endl; } }; int main() { Derived derived1; Base* base1 = &derived1; base1->print(); // imprime Função Derivada return 0; } 

Saída

Função Derivada

Como Base::print é virtual, a chamada despacha para Derived::print mesmo através de um ponteiro base.

---

O Identificador Override em C++

Desde C++11, a palavra-chave override ajuda a prevenir sobrescrita acidental incorreta forçando o compilador a verificar se uma função realmente sobrescreve um membro virtual da base.

Exemplo:

class Base { public: virtual void print() { // implementação base } }; class Derived : public Base { public: void print() override { // implementação derivada } }; 

Se você definir a função de sobrescrita fora da classe, use:

class Derived : public Base { public: void print() override; // declaração }; void Derived::print() { // implementação } 

---

Usando override com Segurança

Sem override, um erro de digitação ou incompatibilidade de assinatura resulta silenciosamente em uma nova função em vez de uma sobrescrita, levando a bugs sutis. O compilador então emitirá um erro, tornando o problema imediatamente visível. Armadilhas comuns incluem:

• Nomes incompatíveis: ex: pint() em vez de print()
• Tipos de retorno diferentes: ex: retornar int em vez de void
• Parâmetros diferentes: listas de parâmetros divergentes
• Virtual ausente na base: a função base não é virtual

---

Uso Prático de Funções Virtuais

Considere uma classe base Animal com classes derivadas Dog e Cat. Cada classe mantém um membro type inicializado por seu construtor.

class Animal { private: string type; public: Animal() : type("Animal") {} virtual string getType() const { return type; } }; class Dog : public Animal { private: string type; public: Dog() : type("Dog") {} string getType() const override { return type; } }; class Cat : public Animal { private: string type; public: Cat() : type("Cat") {} string getType() const override { return type; } }; 

Com getType() virtual, um único helper pode imprimir qualquer animal:

void print(Animal* ani) { cout << "Animal: " << ani->getType() << endl; } 

Uso em main():

int main() { Animal* animal1 = new Animal(); Animal* dog1 = new Dog(); Animal* cat1 = new Cat(); print(animal1); print(dog1); print(cat1); delete animal1; delete dog1; delete cat1; return 0; } 

Saída

Animal: Animal Animal: Dog Animal: Cat

Tornando getType() virtual, evitamos duplicar a lógica de print() em cada classe derivada e garantimos que o type correto seja acessado.