Interfaces en C++ (Clases Abstractas)

Una interfaz describe el comportamiento o las capacidades de una clase de C++ sin comprometerse con una implementación particular de esa clase.

Las interfaces de C++ se implementan usando clases abstractas y estas clases abstractas no deben confundirse con la abstracción de datos, que es un concepto de mantener los detalles de implementación separados de los datos asociados.

Una clase se vuelve abstracta declarando al menos una de sus funciones como virtual pura función. Una función virtual pura se especifica colocando "=0" en su declaración de la siguiente manera −

class Box {
   public:
      // pure virtual function
      virtual double getVolume() = 0;
      
   private:
      double length;      // Length of a box
      double breadth;     // Breadth of a box
      double height;      // Height of a box
};

El propósito de una clase abstracta (a menudo denominado ABC) es proporcionar una clase base adecuada de la que puedan heredar otras clases. Las clases abstractas no se pueden usar para crear instancias de objetos y solo sirven como una interfaz . Intentar instanciar un objeto de una clase abstracta provoca un error de compilación.

Así, si se necesita instanciar una subclase de un ABC, tiene que implementar cada una de las funciones virtuales, lo que significa que soporta la interfaz declarada por el ABC. No anular una función virtual pura en una clase derivada y luego intentar instanciar objetos de esa clase es un error de compilación.

Las clases que se pueden usar para instanciar objetos se denominan clases concretas .

Ejemplo de clase abstracta

Considere el siguiente ejemplo donde la clase principal proporciona una interfaz a la clase base para implementar una función llamada getArea() −

Demostración en vivo

#include <iostream>
 
using namespace std;
 
// Base class
class Shape {
   public:
      // pure virtual function providing interface framework.
      virtual int getArea() = 0;
      void setWidth(int w) {
         width = w;
      }
   
      void setHeight(int h) {
         height = h;
      }
   
   protected:
      int width;
      int height;
};
 
// Derived classes
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);
   
   // Print the area of the object.
   cout << "Total Rectangle area: " << Rect.getArea() << endl;

   Tri.setWidth(5);
   Tri.setHeight(7);
   
   // Print the area of the object.
   cout << "Total Triangle area: " << Tri.getArea() << endl; 

   return 0;
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado −

Total Rectangle area: 35
Total Triangle area: 17

Puede ver cómo una clase abstracta definió una interfaz en términos de getArea() y otras dos clases implementaron la misma función pero con un algoritmo diferente para calcular el área específica de la forma.

Estrategia de diseño

Un sistema orientado a objetos podría usar una clase base abstracta para proporcionar una interfaz común y estandarizada apropiada para todas las aplicaciones externas. Luego, a través de la herencia de esa clase base abstracta, se forman clases derivadas que funcionan de manera similar.

Las capacidades (es decir, las funciones públicas) que ofrecen las aplicaciones externas se proporcionan como funciones virtuales puras en la clase base abstracta. Las implementaciones de estas funciones virtuales puras se proporcionan en las clases derivadas que corresponden a los tipos específicos de la aplicación.

Esta arquitectura también permite agregar fácilmente nuevas aplicaciones a un sistema, incluso después de que se haya definido el sistema.