Plantilla Especialización en C++

La plantilla en C++ es una característica. Escribimos el código una vez y lo usamos para cualquier tipo de datos, incluidos los tipos de datos definidos por el usuario. Por ejemplo, sort() se puede escribir y usar para ordenar elementos de cualquier tipo de datos. Se puede crear una pila de clases que se puede usar como una pila de cualquier tipo de datos. 
¿Qué pasa si queremos un código diferente para un tipo de datos en particular? Considere un gran proyecto que necesita una función sort() para arrays de muchos tipos de datos diferentes. Permita que Quick Sort se use para todos los tipos de datos excepto char. En el caso de char, los valores totales posibles son 256 y la ordenación por conteo puede ser una mejor opción. ¿Es posible usar un código diferente solo cuando se llama a sort() para el tipo de datos char? 
Es posible en C++ obtener un comportamiento especial para un tipo de datos en particular. Esto se llama especialización de plantilla . 

Plantilla nos permite definir clases genéricas y funciones genéricas y así dar soporte a la programación genérica. La programación genérica es un enfoque en el que los tipos de datos genéricos se utilizan como parámetros en los algoritmos para que funcionen para una variedad de tipos de datos adecuados.
Las plantillas a veces se denominan clases o funciones parametrizadas.

// Eg: Let us recall the concept of function overloading
 
#include<iostream>
using namespace std;
 
void show(int,int);
void show(double,double);
void show(char,char);
 
main()
{
    show(2,5);
    show(2.6,7.6);
    return 0;
}
 
void show(int a,int b)
{
    cout<<"a="<<a<<endl;
    cout<<"b="<<b<<endl;
}
 
void show(double a,double b)
{
    cout<<"a="<<a<<endl;
    cout<<"b="<<b<<endl;
}

a=2
b=5
a=2.6
b=7.6

Pero una observación cuidadosa de las funciones sobrecargadas como en nuestro programa nos mostrará la desventaja de la función sobrecargada. Es decir, cada definición de función sobrecargada realiza tareas idénticas. Pero el único cambio/diferencia con la función sobrecargada es que manejan argumentos de diferentes tipos de datos para realizar tareas idénticas. Esto es una desventaja porque, los tipos de datos de los argumentos de la función son diferentes, estamos escribiendo un código separado para la definición de la función para realizar la misma tarea.
Este es un tipo de desventaja y esta desventaja se supera con un nuevo concepto llamado «PLANTILLA DE FUNCIÓN». 
 

// A generic sort function
template <class T>
void sort(T arr[], int size)
{
    // code to implement Quick Sort
}
 
// Template Specialization: A function
// specialized for char data type
template <>
void sort<char>(char arr[], int size)
{
    // code to implement counting sort
}

Otro ejemplo podría ser una clase Set que represente un conjunto de elementos y admita operaciones como unión, intersección, etc. Cuando el tipo de elementos es char, es posible que deseemos usar una array booleana simple de tamaño 256 para crear un conjunto. Para otros tipos de datos, tenemos que usar alguna otra técnica compleja.

PLANTILLA DE FUNCIÓN:-

Las plantillas de funciones permiten al programador escribir una función genérica que es independiente del tipo de datos.
Usando plantillas de funciones, podemos reducir el tamaño del código y facilitar el mantenimiento del código.
 

Sintaxis:

template <class T>
<return-type> <function-name> (  <parameters of type T> )
{
                 //function body
}
Where
template   ------    keyword
class T     ------    template type parameter enclosed within a pair of angle brackets(< >) called generic dt.

// Example:
 
#include<iostream>
using namespace std;
 
template<class T>
void show(T a,T b)
{
    cout<<"a="<<a<<endl;
    cout<<"b="<<b<<endl;
}
 
main()
{
    show(2,5);
    show(2.6,7.6);
    return 0;
}

a=2
b=5
a=2.6
b=7.6

// Create a function template that prints the maximum of two values.
 
#include<iostream>
using namespace std;
 
template<class T>
void getMax(T a,T b)
{
    T result;
    result=(a>b)?a:b;
    cout<<endl<<"Maximum:"<<result;
}
 
main()
{
    getMax(2,5);
    getMax(2.6,7.6);
    getMax('A','D');
    return 0;
}

Maximum:5
Maximum:7.6
Maximum:D

// Example:
 
#include<iostream>
using namespace std;
 
template<class T>
T getMax(T a,T b)
{
    T result;
    result=(a>b)?a:b;
    return result;
}
 
main()
{
  int a=getMax(2,5);
  double d=getMax(2.6,7.6);
  cout<<endl<<a;
  cout<<endl<<d;
    return 0;
}

5
7.6

// create a function template that prints the swap of two numbers.
 
#include<iostream>
using namespace std;
 
template<class T>
void swapp(T &a,T &b)
{
    T temp;
    temp=a;
    a=b;
    b=temp;
}
 
main()
{
  int a=10,b=20;
  double x=20.3,y=55.3;
  
  cout<<endl<<"Before Swap"<<endl;
  cout<<endl<<"A="<<a<<"\t"<<"B="<<b;
  cout<<endl<<"X="<<x<<"\t"<<"B="<<y;
   
   swapp(a,b);
   swapp(x,y);
    
  cout<<endl<<endl<<"After Swap"<<endl;
  cout<<endl<<"A="<<a<<"\t"<<"B="<<b;
  cout<<endl<<"X="<<x<<"\t"<<"B="<<y;
   
    return 0;
}

Before Swap

A=10    B=20
X=20.3    B=55.3

After Swap

A=20    B=10
X=55.3    B=20.3

Nota: Además de los tipos de datos incorporados como int, double, char, etc., el parámetro de plantilla ‘T’ también se puede reemplazar por el tipo de datos definido por el usuario.

Un programa de ejemplo para la especialización de plantillas de funciones 
Por ejemplo, considere el siguiente código simple donde tenemos plantilla general fun() para todos los tipos de datos excepto int. Para int, hay una versión especializada de fun(). 
 

#include <iostream>
using namespace std;
 
template <class T>
void fun(T a)
{
   cout << "The main template fun(): "
        << a << endl;
}
 
template<>
void fun(int a)
{
    cout << "Specialized Template for int type: "
         << a << endl;
}
 
int main()
{
    fun<char>('a');
    fun<int>(10);
    fun<float>(10.14);
}

The main template fun(): a
Specialized Template for int type: 10
The main template fun(): 10.14

Un programa de ejemplo para la especialización de plantillas de clase 
En el siguiente programa, se escribe una versión especializada de la clase Test para el tipo de datos int. 
 

#include <iostream>
using namespace std;
 
template <class T>
class Test
{
  // Data members of test
public:
   Test()
   {
       // Initialization of data members
       cout << "General template object \n";
   }
   // Other methods of Test
};
 
template <>
class Test <int>
{
public:
   Test()
   {
       // Initialization of data members
       cout << "Specialized template object\n";
   }
};
 
int main()
{
    Test<int> a;
    Test<char> b;
    Test<float> c;
    return 0;
}

Specialized template object
General template object 
General template object 

¿Cómo funciona la especialización de plantillas?  
Cuando escribimos cualquier función o clase basada en una plantilla, el compilador crea una copia de esa función/clase cada vez que el compilador ve que se usa para un nuevo tipo de datos o un nuevo conjunto de tipos de datos (en el caso de múltiples argumentos de plantilla). 
Si hay una versión especializada, el compilador primero verifica con la versión especializada y luego con la plantilla principal. El compilador primero verifica con la versión más especializada haciendo coincidir el parámetro pasado con los tipos de datos especificados en una versión especializada. 
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.