Polimorfismos ad-hoc, de inclusión, paramétricos y de coerción

Cuando hablamos de polimorfismo en C++, llegamos a escuchar los siguientes cuatro tipos:

Discutiendo esto en detalle:

Polimorfismo ad-hoc , también llamado sobrecarga

El polimorfismo ad-hoc permite que las funciones que tienen el mismo nombre actúen de manera diferente para diferentes tipos. Por ejemplo:
el operador + suma dos enteros y concatena dos strings.

El ejemplo anterior podría ilustrarse mejor invocando la función «sum()» en el código mencionado a continuación:

#include <iostream>
using namespace std;
  
int sum(int x, int y)
{
    int c = x + y;
    return c;
}
  
string sum(const char* x, const char* y)
{
    string summation(x);
    summation += y;
    return summation;
}
  
int main()
{
    cout << sum(50, 20)
         << " :- Integer addition Output\n";
    cout << sum("Polymorphism", " achieved")
         << " :- String Concatenation Output\n";
}

Producción:

70 :- Integer addition Output
Polymorphism achieved :- String Concatenation Output

Por lo tanto, al llamar a dos funciones diferentes (que difieren en el tipo de argumentos) que tienen los mismos nombres para ejecutar varias operaciones, hemos logrado con éxito el polimorfismo ad-hoc.

Polimorfismo de inclusión , también llamado subtipado

El polimorfismo de inclusión es la capacidad de usar clases derivadas a través de referencias y punteros de clase base. También se conoce como polimorfismo en tiempo de ejecución porque el compilador no encuentra la dirección de la función en tiempo de compilación, sino que se elimina la referencia del puntero derecho de la tabla virtual para invocar la función en tiempo de ejecución.
El concepto de Función Virtual, también conocido como Vinculación Dinámica, se emplea para lograr el Polimorfismo de Inclusión. El uso de la función virtual permite la selección de la función que se va a invocar en función del tipo de objeto para el que se llama.
Por ejemplo:
para implementar una técnica de polimorfismo de este tipo, consideremos diferentes archivos, como archivos .jpg, .gif, .png. Todos estos archivos pertenecen a la categoría de archivos de imagen.

Por lo tanto, se pueden representar como clases derivadas de la clase base de imagen y anular la función virtual pura display(). El ejemplo anterior podría entenderse mejor con la siguiente ilustración:

#include <iostream>
using namespace std;
  
class Image {
  
public:
    Image()
    {
    }
  
    virtual void display() = 0;
};
class Jpg : public Image {
public:
    Jpg()
    {
    }
  
    void display()
    {
        cout << "JPG Image File" << endl;
    }
};
  
class Png : public Image {
public:
    Png()
    {
    }
  
    void display()
    {
        cout << "PNG Image File" << endl;
    }
};
  
// Main function
int main()
{
    Image* img;
    Jpg jg;
    Png pg;
  
    // stores the address of Jpg
    img = &jg;
  
    // invoking display() func of Jpg
    img->display();
  
    // stores the address of Png
    img = &pg;
  
    // invoking display() func of Png
    img->display();
  
    return 0;
}

Producción:

JPG Image File
PNG Image File

Por lo tanto, en el código anterior, tenemos dos Clases diferentes con una función que tiene el mismo nombre y no difiere en Parámetros, pero con diferentes implementaciones.

Polimorfismo de coerción , también llamado Casting

El polimorfismo de coerción ocurre cuando un objeto o primitivo se convierte en algún otro tipo. Puede ser Implícito o Explícito.

La conversión implícita ocurre como responsabilidad del propio compilador.
Por ejemplo:
float f=100
(el entero se promociona implícitamente a float)

La conversión explícita hace uso de algunas expresiones de conversión de tipo como const_cast, dynamic_cast, etc.
Por ejemplo:
cuando una clase define un operador de conversión para algún tipo, diga «int», entonces, podría emplearse en cualquier parte del programa donde los datos de tipo entero se espera.
La ilustración a continuación podría hacer que sea más fácil de entender:

Esta ilustración anterior podría aclararse más con la ayuda del código a continuación:

#include <iostream>
using namespace std;
  
class IntClass {
    int num;
  
public:
    IntClass(int a)
        : num(a)
    {
    }
  
    operator int() const
    {
        return num;
    } // conversion from User-defined type to Basic type
};
  
void show(int x)
{
    cout << x << endl;
}
  
int main()
{
    IntClass i = 100;
    show(746); // outputs 746
    show(i); // outputs 100
}

Producción:

746
100

La referencia IntClass se usa en lugar del argumento de tipo entero y, por lo tanto, el concepto de Casting se entiende bien.

Polimorfismo paramétrico , también llamado enlace temprano

El polimorfismo paramétrico abre una forma de usar la misma pieza de código para diferentes tipos. Se implementa mediante el uso de Plantillas.
Por ejemplo:
para desarrollar una comprensión de este tipo de polimorfismo, ejecutemos un programa para encontrar el mayor de dos enteros o dos strings,

#include <iostream>
#include <string>
using namespace std;
  
template <class temp>
temp greater(temp a, temp b)
{
    if (a > b)
        return a;
    else
        return b;
}
  
int main()
{
    cout << ::greater(55, 11) << endl;
  
    string str1("Early"), str2("Binding");
    cout << ::greater(str1, str2) << endl;
}

Producción:

55
Early

Usando plantillas, la misma función se puede parametrizar con diferentes tipos de datos, pero esto debe decidirse en el momento de la compilación y, por lo tanto, este polimorfismo se llama así.
Si deseamos lograr dicho polimorfismo para punteros, se convierte en polimorfismo ad-hoc.

Publicación traducida automáticamente

Artículo escrito por suryahome0000 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta