Interfaces em C++: Dominando Classes Abstratas e Funções Virtuais Puras

Uma interface descreve o comportamento ou capacidades de uma classe C++ sem se comprometer com uma implementação particular dessa classe.

As interfaces em C++ são implementadas usando classes abstratas e estas classes abstratas não devem ser confundidas com abstração de dados, que é um conceito de manter detalhes de implementação separados dos dados associados.

Uma classe torna-se abstrata declarando pelo menos uma de suas funções como função virtual pura. Uma função virtual pura é especificada colocando "= 0" em sua declaração da seguinte forma:

class Box {
public:
    // pure virtual function
    virtual double getVolume() = 0;
private:
    double length;  // Comprimento de uma caixa
    double breadth; // Largura de uma caixa
    double height;  // Altura de uma caixa
};

O propósito de uma classe abstrata (frequentemente referida como ABC) é fornecer uma classe base apropriada a partir da qual outras classes podem herdar. Classes abstratas não podem ser usadas para instanciar objetos e servem apenas como interface. Tentar instanciar um objeto de uma classe abstrata causa erro de compilação.

Assim, se uma subclasse de uma ABC precisa ser instanciada, ela deve implementar cada uma das funções virtuais, o que significa que suporta a interface declarada pela ABC. Falhar em sobrescrever uma função virtual pura em uma classe derivada e então tentar instanciar objetos dessa classe é um erro de compilação.

Classes que podem ser usadas para instanciar objetos são chamadas de classes concretas.

Exemplo de Classe Abstrata

Considere o exemplo a seguir onde a classe pai fornece uma interface à classe base para implementar uma função chamada getArea():

#include <iostream>
using namespace std;
// Classe base
class Shape {
public:
    // pure virtual function fornecendo framework de interface
    virtual int getArea() = 0;
    void setWidth(int w) { width = w; }
    void setHeight(int h) { height = h; }
protected:
    int width;
    int height;
};
// Classes derivadas
class Rectangle: public Shape {
public:
    int getArea() { return (width * height); }
};
class Triangle: public Shape {
public:
    int getArea() { return (width * height) / 2; }
};
int main(void) {
    Rectangle Rect;
    Triangle Tri;
    Rect.setWidth(5);
    Rect.setHeight(7);
    // Imprime área do objeto
    cout << "Total Rectangle area: " << Rect.getArea() << endl;
    Tri.setWidth(5);
    Tri.setHeight(7);
    // Imprime área do objeto
    cout << "Total Triangle area: " << Tri.getArea() << endl;
    return 0;
}

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

Total Rectangle area: 35
Total Triangle area: 17

Você pode ver como uma classe abstrata definiu uma interface em termos de getArea() e duas outras classes implementaram a mesma função mas com algoritmos diferentes para calcular a área específica da forma.

Estratégia de Design

Um sistema orientado a objetos pode usar uma classe base abstrata para fornecer uma interface comum e padronizada apropriada para todas as aplicações externas. Então, através de herança a partir dessa classe base abstrata, classes derivadas são formadas que operam de forma similar.

As capacidades (ou seja, as funções públicas) oferecidas pelas aplicações externas são fornecidas como funções virtuais puras na classe base abstrata. As implementações dessas funções virtuais puras são fornecidas nas classes derivadas que correspondem aos tipos específicos da aplicação.

Esta arquitetura também permite que novas aplicações sejam adicionadas a um sistema facilmente, mesmo após o sistema ter sido definido.