Genéricos en C++

Generics es la idea de permitir que el tipo (entero, string, etc. y tipos definidos por el usuario) sea un parámetro para métodos, clases e interfaces. Por ejemplo, clases como una array, un mapa, etc., que se pueden usar usando genéricos de manera muy eficiente. Podemos utilizarlos para cualquier tipo.

Se implementa el método de Programación Genérica para aumentar la eficiencia del código. La programación genérica permite al programador escribir un algoritmo general que funcionará con todos los tipos de datos. Elimina la necesidad de crear diferentes algoritmos si el tipo de datos es un número entero, una string o un carácter.

Las ventajas de la Programación Genérica son

1. Reutilización de código
2. Evite la sobrecarga de funciones
3. Una vez escrito, se puede utilizar para múltiples ocasiones y casos.

Los genéricos se pueden implementar en C++ usando Plantillas . Template es una herramienta simple pero muy poderosa en C++. La idea simple es pasar el tipo de datos como un parámetro para que no necesitemos escribir el mismo código para diferentes tipos de datos. Por ejemplo, una empresa de software puede necesitar sort() para diferentes tipos de datos. En lugar de escribir y mantener varios códigos, podemos escribir un sort() y pasar el tipo de datos como parámetro.

Funciones genéricas usando plantilla:

Escribimos una función genérica que se puede usar para diferentes tipos de datos. Ejemplos de plantillas de funciones son sort(), max(), min(), printArray()

#include <iostream>
using namespace std;
  
// One function works for all data types.
// This would work even for user defined types
// if operator '>' is overloaded
template <typename T>
  
T myMax(T x, T y)
{
    return (x > y) ? x : y;
}
  
int main()
{
  
    // Call myMax for int
    cout << myMax<int>(3, 7) << endl;
  
    // call myMax for double
    cout << myMax<double>(3.0, 7.0) << endl;
  
    // call myMax for char
    cout << myMax<char>('g', 'e') << endl;
  
    return 0;
}

7
7
g

Clase genérica usando plantilla:

Al igual que las plantillas de funciones, las plantillas de clases son útiles cuando una clase define algo que es independiente del tipo de datos. Puede ser útil para clases como LinkedList, árbol binario, Stack, Queue, Array, etc.

A continuación se muestra un ejemplo simple de la clase Array de plantilla.

#include <iostream>
using namespace std;
  
template <typename T>
class Array {
private:
    T* ptr;
    int size;
  
public:
    Array(T arr[], int s);
    void print();
};
  
template <typename T>
Array<T>::Array(T arr[], int s)
{
    ptr = new T[s];
    size = s;
    for (int i = 0; i < size; i++)
        ptr[i] = arr[i];
}
  
template <typename T>
void Array<T>::print()
{
    for (int i = 0; i < size; i++)
        cout << " " << *(ptr + i);
    cout << endl;
}
  
int main()
{
    int arr[5] = { 1, 2, 3, 4, 5 };
    Array<int> a(arr, 5);
    a.print();
    return 0;
}

1 2 3 4 5

Trabajar con genéricos multitipo:

Podemos pasar más de un tipo de datos como argumentos a las plantillas. El siguiente ejemplo demuestra lo mismo.

#include <iostream>
using namespace std;
  
template <class T, class U>
class A {
    T x;
    U y;
  
public:
    A()
    {
        cout << "Constructor Called" << endl;
    }
};
  
int main()
{
    A<char, char> a;
    A<int, double> b;
    return 0;
}

Constructor Called
Constructor Called