Polimorfismo en C++ explicado: Ejemplos prácticos y conceptos clave

¿Qué es el polimorfismo en C++?

En C++, el polimorfismo hace que una función miembro se comporte de manera diferente según el objeto que la llama/invoca. Polimorfismo es una palabra griega que significa "tener muchas formas". Ocurre cuando tiene una jerarquía de clases relacionadas mediante herencia.

Por ejemplo, supongamos que tenemos la función hacerSonido(). Cuando un gato llama a esta función, producirá un maullido. Cuando una vaca invoca la misma función, producirá un mugido.

Aunque tenemos una sola función, se comporta diferente bajo distintas circunstancias. La función tiene muchas formas; por tanto, hemos logrado polimorfismo.

En este tutorial de C++ aprenderá:

• Qué es el polimorfismo
• Tipos de polimorfismo
• Polimorfismo en tiempo de compilación
• Sobrecarga de funciones
• Sobrecarga de operadores
• Polimorfismo en tiempo de ejecución
• Sobrescritura de funciones
• Función virtual en C++
• Polimorfismo en tiempo de compilación vs. tiempo de ejecución

Tipos de polimorfismo

C++ soporta dos tipos de polimorfismo:

• Polimorfismo en tiempo de compilación, y
• Polimorfismo en tiempo de ejecución.

Polimorfismo en tiempo de compilación

Invoca las funciones sobrecargadas coincidiendo con el número y tipo de argumentos. La información está presente durante la compilación. Esto significa que el compilador de C++ seleccionará la función correcta en tiempo de compilación.

El polimorfismo en tiempo de compilación se logra mediante sobrecarga de funciones y sobrecarga de operadores.

Sobrecarga de funciones

La sobrecarga de funciones ocurre cuando tenemos muchas funciones con nombres similares pero argumentos diferentes. Los argumentos pueden diferir en número o tipo.

Ejemplo 1:

#include <iostream>
using namespace std;
void test(int i) {
    cout << "El int es " << i << endl;
}
void test(double f) {
    cout << "El float es " << f << endl;
}
void test(char const *ch) {
    cout << "El char* es " << ch << endl;
}
int main() {
    test(5);
    test(5.5);
    test("cinco");
    return 0;
}

Salida:

Captura del código:

Explicación del código:

1. Incluya cabecera iostream para usar sus funciones.
2. Incluya espacio de nombres std para usar sus clases sin llamarlas.
3. Cree función test que tome parámetro entero i. { marca inicio del cuerpo.
4. Sentencia a ejecutar si se invoca la función test anterior.
5. Fin del cuerpo de la función test anterior.
6. Cree función test que tome parámetro float f. { marca inicio del cuerpo.
7. Sentencia a ejecutar si se invoca la función test anterior.
8. Fin del cuerpo de la función test anterior.
9. Cree función test que tome parámetro carácter ch. { marca inicio del cuerpo.
10. Sentencia a ejecutar si se invoca la función test anterior.
11. Fin del cuerpo de la función test anterior.
12. Llame a main(). { marca inicio del cuerpo.
13. Llame a test pasando 5. Invoca test que acepta entero (primera función).
14. Llame a test pasando 5.5. Invoca test que acepta float (segunda función).
15. Llame a test pasando "cinco". Invoca test que acepta carácter (tercera función).
16. El programa debe retornar valor si se ejecuta exitosamente.
17. Fin del cuerpo de main().

Tenemos tres funciones con el mismo nombre pero diferentes tipos de argumentos. Hemos logrado polimorfismo.

Sobrecarga de operadores

En la sobrecarga de operadores, definimos un nuevo significado para un operador de C++. También cambia cómo funciona el operador. Por ejemplo, podemos definir el operador + para concatenar dos cadenas. Lo conocemos como operador de adición para sumar valores numéricos. Tras nuestra definición, cuando se coloca entre enteros, los sumará. Cuando se coloca entre cadenas, las concatenará.

Ejemplo 2:

#include<iostream>
using namespace std;
class NumeroComplejo {
private:
    int real, imag;
public:
    NumeroComplejo(int rl = 0, int im = 0) {
        real = rl;
        imag = im;
    }
    NumeroComplejo operator + (NumeroComplejo const &obj) {
        NumeroComplejo resultado;
        resultado.real = real + obj.real;
        resultado.imag = imag + obj.imag;
        return resultado;
    }
    void imprimir() {
        cout << real << " + i" << imag << endl;
    }
};
int main() {
    NumeroComplejo c1(10, 2), c2(3, 7);
    NumeroComplejo c3 = c1 + c2;
    c3.imprimir();
}

Salida:

Captura del código:

Explicación del código:

1. Incluya iostream para usar sus funciones.
2. Incluya espacio de nombres std.
3. Cree clase NumeroComplejo. { marca inicio del cuerpo.
4. Use modificador private para marcar variables como privadas (solo accesibles dentro de la clase).
5. Defina dos variables enteras: real e imag.
6. Use public para marcar constructor como público (accesible desde fuera).
7. Cree constructor inicializando variables.
8. Inicialice valor de real.
9. Inicialice valor de imag.
10. Fin del cuerpo del constructor.
11. Necesitamos sobrescribir el significado del operador +.
12. Cree tipo de dato resultado de tipo NumeroComplejo.
13. Use operador + con números complejos. Esta línea suma la parte real de un número a la parte real de otro.
14. Use operador + con números complejos. Esta línea suma la parte imaginaria de un número a la parte imaginaria de otro.
15. El programa retornará el valor de resultado al completarse exitosamente.
16. Fin de la definición del nuevo significado de + (sobrecarga).
17. Llame al método imprimir().
18. Imprima el nuevo número complejo tras la adición en consola.
19. Fin del cuerpo de imprimir().
20. Fin del cuerpo de la clase NumeroComplejo.
21. Llame a main().
22. Pase valores de partes real e imaginaria a sumar. Primera parte de c1 se suma a primera de c2 (10+3). Segunda parte de c1 se suma a segunda de c2 (2+7).
23. Realice operación usando operador + sobrecargado y guarde resultado en c3.
24. Imprima valor de c3 en consola.
25. Fin del cuerpo de main().

Polimorfismo en tiempo de ejecución

Esto ocurre cuando el método de un objeto es invocado/llamado durante la ejecución en lugar de durante la compilación. El polimorfismo en tiempo de ejecución se logra mediante sobrescritura de funciones. La función a llamar se establece durante la ejecución.

Sobrescritura de funciones

La sobrescritura de funciones ocurre cuando una función de la clase base recibe una nueva definición en una clase derivada. En ese momento, decimos que la función base ha sido sobrescrita.

Por ejemplo:

#include <iostream>
using namespace std;
class Mamifero {
public:
    void comer() {
        cout << "Los mamíferos comen...";
    }
};
class Vaca : public Mamifero {
public:
    void comer() {
        cout << "Las vacas comen hierba...";
    }
};
int main(void) {
    Vaca v = Vaca();
    v.comer();
    return 0;
}

Salida:

Captura del código:

Explicación del código:

1. Importe iostream para usar sus funciones.
2. Incluya espacio de nombres std.
3. Cree clase Mamifero. { marca inicio del cuerpo.
4. Use public para marcar la función que crearemos como públicamente accesible.
5. Cree función pública comer(). { marca inicio del cuerpo.
6. Imprima la sentencia añadida a cout cuando comer() se invoque.
7. Fin del cuerpo de comer().
8. Fin del cuerpo de la clase Mamifero.
9. Cree clase Vaca que hereda de Mamifero. Vaca es clase derivada, Mamifero es base. { marca inicio.
10. Use public para marcar función como públicamente accesible.
11. Sobrescriba la función comer() definida en la clase base. { marca inicio del cuerpo.
12. Sentencia a imprimir en consola cuando esta función se invoque.
13. Fin del cuerpo de comer().
14. Fin del cuerpo de la clase Vaca.
15. Llame a main(). { marca inicio del cuerpo.
16. Cree instancia de Vaca dándole nombre v.
17. Llame a comer() definido en Vaca.
18. El programa debe retornar valor al completarse exitosamente.
19. Fin de main().

Función virtual en C++

Una función virtual es otra forma de implementar polimorfismo en tiempo de ejecución en C++. Es una función especial definida en una clase base y redefinida en la clase derivada. Para declarar una función virtual, use la palabra clave virtual. La palabra clave debe preceder la declaración de la función en la clase base.

Si una clase virtual es heredada, la clase derivada redefine la función virtual para adaptarla a sus necesidades. Por ejemplo:

#include <iostream>
using namespace std;
class ClaseA {
public:
    virtual void mostrar() {
        cout << "La función mostrar() en clase base invocada..." << endl;
    }
};
class ClaseB :public ClaseA {
public:
    void mostrar() {
        cout << "La función mostrar() en clase derivada invocada...";
    }
};
int main() {
    ClaseA* a;
    ClaseB b;
    a = &b;
    a->mostrar();
}

Salida:

Captura del código:

Explicación del código:

1. Incluya iostream en el código para usar sus funciones.
2. Incluya espacio de nombres std.
3. Cree clase ClaseA.
4. Use public para marcar miembro como públicamente accesible.
5. Cree función virtual mostrar(). Será pública.
6. Texto a imprimir cuando mostrar() se invoque. endl mueve cursor a siguiente línea.
7. Fin del cuerpo de la función virtual mostrar().
8. Fin del cuerpo de ClaseA.
9. Cree nueva clase ClaseB que hereda ClaseA. ClaseA es base, ClaseB es derivada.
10. Use public para marcar miembro como públicamente accesible.
11. Redefina la función virtual mostrar() definida en la base.
12. Texto a imprimir cuando mostrar() definido en derivada se invoque.
13. Fin del cuerpo de mostrar().
14. Fin del cuerpo de la clase derivada ClaseB.
15. Llame a main(). La lógica del programa va en su cuerpo.
16. Cree variable puntero a. Apunta a ClaseA.
17. Cree instancia de ClaseB llamada b.
18. Asigne la dirección almacenada en b a la variable a.
19. Invoque la función mostrar() definida en la clase derivada. Se ha implementado enlace tardío (late binding).
20. Fin del cuerpo de main().

Polimorfismo en tiempo de compilación vs. tiempo de ejecución

Aquí están las principales diferencias:

Polimorfismo en tiempo de compilación	Polimorfismo en tiempo de ejecución
También llamado enlace temprano (early binding) o polimorfismo estático	También llamado enlace tardío (late/dynamic binding) o polimorfismo dinámico
El método se llama/invoca durante la compilación	El método se llama/invoca durante la ejecución
Implementado vía sobrecarga de funciones y operadores	Implementado vía sobrescritura de métodos y funciones virtuales
Ejemplo: sobrecarga de métodos. Muchos métodos con nombres similares pero diferente número o tipos de argumentos	Ejemplo: sobrescritura de métodos. Muchos métodos con nombre similar y mismo prototipo
Ejecución más rápida ya que el descubrimiento de métodos ocurre en compilación	Ejecución más lenta ya que el descubrimiento ocurre en tiempo de ejecución
Menos flexibilidad para resolver problemas ya que todo se conoce en compilación	Mucha flexibilidad para resolver problemas complejos ya que métodos se descubren en ejecución

Resumen:

• Polimorfismo significa tener muchas formas.
• Ocurre cuando hay una jerarquía de clases relacionadas mediante herencia.
• Con polimorfismo, una función puede comportarse diferente según el objeto que la invoca/llama.
• En polimorfismo en tiempo de compilación, la función a invocar se establece durante la compilación.
• En polimorfismo en tiempo de ejecución, la función a invocar se establece durante la ejecución.
• El polimorfismo en tiempo de compilación se determina mediante sobrecarga de funciones y operadores.
• En sobrecarga de funciones, hay muchas funciones con nombres similares pero argumentos diferentes.
• Los parámetros pueden diferir en número o tipo.
• En sobrecarga de operadores, se define un nuevo significado para operadores de C++.
• El polimorfismo en tiempo de ejecución se logra mediante sobrescritura de funciones.
• En sobrescritura, una clase derivada da nueva definición a una función definida en la clase base.