Función virtual

Por ejemplo, una clase base Animal podría tener una función virtual come. La subclase Pez implementaría come() de forma diferente que la subclase Lobo, pero se podría invocar a come() en cualquier instancia de una clase referida como Animal, y obtener el comportamiento de come() de la subclase específica.

Esto permitiría a un programador procesar una lista de objetos de la clase Animal, diciendo a cada uno que coma (llamando a come()), sin saber qué tipo de animales hay en la lista. Tampoco tendría que saber cómo come cada animal, o cuántos tipos de animales puede llegar a existir.

El siguiente, es un ejemplo en C++:

# include <iostream>
class Animal
{
public:
    virtual void come() { std::cout << "Yo como como un animal genérico.\n"; }
    virtual ~Animal() {}
};
 
class Lobo : public Animal
{
public:
    void come() { std::cout << "¡Yo como como un lobo!\n"; }
    virtual ~Lobo() {}
};
 
class Pez : public Animal
{
public:
    void come() { std::cout << "¡Yo como como un pez!\n"; }
    virtual ~Pez() {}
};
 
class OtroAnimal : public Animal
{
    virtual ~OtroAnimal() {}
};
 
int main()
{
    Animal *unAnimal[4];
    unAnimal[0] = new Animal();
    unAnimal[1] = new Lobo();
    unAnimal[2] = new Pez();
    unAnimal[3] = new OtroAnimal();
 
    for(int i = 0; i < 4; i++) {
        unAnimal[i]->come();
    }
    
    for (int i = 0; i < 4; i++) {
        delete unAnimal[i];
    }
    return 0;
}

Salida con el método virtual come:

Yo como como un animal genérico.
¡Yo como como un lobo!
¡Yo como como un pez!
Yo como como un animal genérico.

Salida sin el método virtual come:

Yo como como un animal genérico.
Yo como como un animal genérico.
Yo como como un animal genérico.
Yo como como un animal genérico.

Una función virtual pura o método virtual puro es una función virtual que necesita ser implementada por una clase derivada que no sea abstracta. Las clases que contienen métodos virtuales puros son denominadas "abstractas". Estas no pueden ser instanciadas directamente, y una subclase de una clase abstracta sólo puede ser instanciada directamente si todos los métodos virtuales puros han sido implementados por esa clase o una clase padre.

Los métodos virtuales puros normalmente tienen una declaración (cabecera) pero no tienen definición (implementación). Como ejemplo, una clase base abstracta como "SimboloMatematico" puede ofrecer una función virtual pura como hazOperacion, y las clases derivadas "Suma" y "Resta" pueden implementar hazOperacion para ofrecer implementaciones concretas. La implementación de hazOperacion no tendría sentido en la clase "SimboloMatematico" porque "SimboloMatematico" es un concepto abstracto cuyo comportamiento es definido solamente por cada tipo (subclase) de "SimboloMatematico" dado.

De forma similar, una subclase dada de "SimboloMatematico" no sería completa sin una implementación de hazOperacion. Aunque los métodos virtuales puros normalmente no tienen implementación en la clase que los declara, en C++ permite hacer esto, ofreciendo un comportamiento por omisión en el que la clase derivada puede delegar si es apropiado.

Las funciones virtuales puras también son utilizadas donde las declaraciones de métodos se utilizan para definir una interfaz para la que las clases derivadas proveerán todas las implementaciones. Una clase abstracta sirviendo como interfaz contiene sólo funciones virtuales puras, y ningún miembro de datos (variables, constantes, etc.) ni métodos ordinarios. El uso de clases puramente abstractas como interfaces funciona en C++ ya que este soporta herencia múltiple. Debido a que muchos lenguajes orientados a objetos no soportan herencia múltiple, normalmente ofrecen un mecanismo por separado para hacer interfaces. Esto es así por ejemplo en Java.

 class B {
   virtual void una_funcion_virtual_pura() = 0;
 };

void Abstracta::virtual_pura() {
  // haz algo
}

class Hija : Abstracta {
  virtual void virtual_pura(); // ya no es abstracta; puede ser instanciada
};

void Hija::virtual_pura() {
  Abstracta::virtual_pura(); // se ejecuta la implementación de la clase abstracta
}

Los lenguajes orientados a objetos normalmente gestionan la reserva y la liberación de memoria automáticamente cuando los objetos son creados y destruidos. Sin embargo, algunos lenguajes orientados a objetos permiten implementar un método destructor personalizado si se desea. Uno de estos lenguajes es C++, y como se ilustra en el siguiente ejemplo, es importante para una clase base de C++ tener un destructor virtual para asegurar que se llamará siempre al destructor de las clases derivadas inferiores. En el ejemplo siguiente, sin destructor virtual, al aplicarle el operador "delete" a una instancia de la clase B, se llamará correctamente al destructor de la clase B y al de la clase A si se elimina como instancia de B; una instancia de B, eliminada mediante un puntero a su clase base A, fallará al no llamar al destructor de B.

# include <iostream>

class A
{
public:
 
   A() { }
   ~A() { std::cout << "Destruye A" << std::endl; }
};
 
class B : public A
{
public:

  B() { }
  ~B() { std::cout << "Destruye B" << std::endl; }
};
 
int main()
{
  A* b1 = new B;
  B* b2 = new B;

  delete b1; // Sólo se llama a ~A() aunque b1 sea una instancia de la clase B
             // porque ~A() no se ha declarado como virtual
  delete b2; // Llama a los destructores ~B() y ~A()

  return 0;
}

Salida:

Destruye A
Destruye B
Destruye A

La declaración correcta del destructor para la clase A como virtual ~A() asegurará que el destructor para la clase B sea llamado en ambos casos del ejemplo anterior.

• Herencia (programación orientada a objetos)
• Herencia virtual

• C++ FAQ Lite Copyright © 1991-2006, Marshall Cline. (en inglés)