Entendendo Polimorfismo em C++: Guia Prático

A palavra polimorfismo significa ter muitas formas. Tipicamente, polimorfismo ocorre quando há uma hierarquia de classes e elas são relacionadas por herança.

Polimorfismo em C++ significa que uma chamada a uma função membro fará com que uma função diferente seja executada dependendo do tipo de objeto que invoca a função.

Considere o exemplo a seguir onde uma classe base foi derivada por outras duas classes:

#include <iostream>
using namespace std;
class Shape {
protected:
    int width, height;
public:
    Shape(int a = 0, int b = 0) {
        width = a; height = b;
    }
    int area() {
        cout << "Parent class area:" << endl;
        return 0;
    }
};
class Rectangle: public Shape {
public:
    Rectangle(int a = 0, int b = 0): Shape(a, b) { }
    int area() {
        cout << "Rectangle class area:" << endl;
        return (width * height);
    }
};
class Triangle: public Shape {
public:
    Triangle(int a = 0, int b = 0): Shape(a, b) { }
    int area() {
        cout << "Triangle class area:" << endl;
        return (width * height / 2);
    }
};
// Função principal do programa
int main() {
    Shape *shape;
    Rectangle rec(10,7);
    Triangle tri(10,5);
    // armazena endereço do Rectangle
    shape = &rec;
    // chama área do retângulo
    shape->area();
    // armazena endereço do Triangle
    shape = &tri;
    // chama área do triângulo
    shape->area();
    return 0;
}

Quando o código acima é compilado e executado, produz o seguinte resultado:

Parent class area:
Parent class area:

A razão para a saída incorreta é que a chamada da função area() está sendo definida uma vez pelo compilador como a versão definida na classe base. Isso é chamado de resolução estática da chamada de função, ou ligação estática — a chamada de função é fixada antes da execução do programa. Isso também é às vezes chamado de early binding (ligação antecipada) porque a função area() é definida durante a compilação do programa.

Mas agora, vamos fazer uma pequena modificação no nosso programa e preceder a declaração de area() na classe Shape com a palavra-chave virtual para que fique assim:

class Shape {
protected:
    int width, height;
public:
    Shape(int a = 0, int b = 0) {
        width = a; height = b;
    }
    virtual int area() {
        cout << "Parent class area:" << endl;
        return 0;
    }
};

Após esta pequena modificação, quando o código do exemplo anterior é compilado e executado, produz o seguinte resultado:

Rectangle class area
Triangle class area

Desta vez, o compilador olha para o conteúdo do ponteiro em vez de seu tipo. Portanto, como endereços de objetos das classes tri e rec são armazenados em *shape, a respectiva função area() é chamada.

Como você pode ver, cada uma das classes filhas tem uma implementação separada para a função area(). É assim que o polimorfismo é geralmente usado. Você tem diferentes classes com uma função do mesmo nome, e até mesmo os mesmos parâmetros, mas com implementações diferentes.

Função Virtual

Uma função virtual é uma função em uma classe base declarada usando a palavra-chave virtual. Definir em uma classe base uma função virtual, com outra versão em uma classe derivada, sinaliza ao compilador que não queremos ligação estática para esta função.

O que queremos é que a seleção da função a ser chamada em qualquer ponto do programa seja baseada no tipo de objeto para o qual é chamada. Este tipo de operação é referido como ligação dinâmica ou late binding (ligação tardia).

Funções Virtuais Puras

É possível que você queira incluir uma função virtual em uma classe base para que ela possa ser redefinida em uma classe derivada para atender aos objetos daquela classe, mas que não haja definição significativa que você possa dar para a função na classe base.

Podemos mudar a função virtual area() na classe base para o seguinte:

class Shape {
protected:
    int width, height;
public:
    Shape(int a = 0, int b = 0) {
        width = a; height = b;
    }
    // pure virtual function
    virtual int area() = 0;
};

O = 0 diz ao compilador que a função não tem corpo e a função virtual acima será chamada de função virtual pura.