Plantillas C++

Las plantillas son la base de la programación genérica, que implica escribir código de forma independiente de cualquier tipo en particular.

Una plantilla es un modelo o fórmula para crear una clase genérica o una función. Los contenedores de la biblioteca, como los iteradores y los algoritmos, son ejemplos de programación genérica y se han desarrollado utilizando el concepto de plantilla.

Hay una sola definición de cada contenedor, como vector , pero podemos definir muchos tipos diferentes de vectores, por ejemplo, vector o vector .

Puede usar plantillas para definir funciones y clases, veamos cómo funcionan −

Plantilla de funciones

La forma general de una definición de función de plantilla se muestra aquí −

template <class type> ret-type func-name(parameter list) {
   // body of function
} 

Aquí, tipo es un nombre de marcador de posición para un tipo de datos utilizado por la función. Este nombre se puede utilizar dentro de la definición de la función.

El siguiente es el ejemplo de una plantilla de función que devuelve el máximo de dos valores −

Demostración en vivo

#include <iostream>
#include <string>

using namespace std;

template <typename T>
inline T const& Max (T const& a, T const& b) { 
   return a < b ? b:a; 
}

int main () {
   int i = 39;
   int j = 20;
   cout << "Max(i, j): " << Max(i, j) << endl; 

   double f1 = 13.5; 
   double f2 = 20.7; 
   cout << "Max(f1, f2): " << Max(f1, f2) << endl; 

   string s1 = "Hello"; 
   string s2 = "World"; 
   cout << "Max(s1, s2): " << Max(s1, s2) << endl; 

   return 0;
}

Si compilamos y ejecutamos el código anterior, esto produciría el siguiente resultado −

Max(i, j): 39
Max(f1, f2): 20.7
Max(s1, s2): World

Plantilla de clase

Así como podemos definir plantillas de funciones, también podemos definir plantillas de clases. La forma general de una declaración de clase genérica se muestra aquí −

template <class type> class class-name {
   .
   .
   .
}

Aquí, escriba es el nombre del tipo de marcador de posición, que se especificará cuando se cree una instancia de una clase. Puede definir más de un tipo de datos genéricos utilizando una lista separada por comas.

El siguiente es el ejemplo para definir la clase Stack<> e implementar métodos genéricos para empujar y sacar los elementos de la pila −

Demostración en vivo

#include <iostream>
#include <vector>
#include <cstdlib>
#include <string>
#include <stdexcept>

using namespace std;

template <class T>
class Stack { 
   private: 
      vector<T> elems;    // elements 

   public: 
      void push(T const&);  // push element 
      void pop();               // pop element 
      T top() const;            // return top element 
      
      bool empty() const {      // return true if empty.
         return elems.empty(); 
      } 
}; 

template <class T>
void Stack<T>::push (T const& elem) { 
   // append copy of passed element 
   elems.push_back(elem);    
} 

template <class T>
void Stack<T>::pop () { 
   if (elems.empty()) { 
      throw out_of_range("Stack<>::pop(): empty stack"); 
   }
   
   // remove last element 
   elems.pop_back();         
} 

template <class T>
T Stack<T>::top () const { 
   if (elems.empty()) { 
      throw out_of_range("Stack<>::top(): empty stack"); 
   }
   
   // return copy of last element 
   return elems.back();      
} 

int main() { 
   try {
      Stack<int>         intStack;  // stack of ints 
      Stack<string> stringStack;    // stack of strings 

      // manipulate int stack 
      intStack.push(7); 
      cout << intStack.top() <<endl; 

      // manipulate string stack 
      stringStack.push("hello"); 
      cout << stringStack.top() << std::endl; 
      stringStack.pop(); 
      stringStack.pop(); 
   } catch (exception const& ex) { 
      cerr << "Exception: " << ex.what() <<endl; 
      return -1;
   } 
} 

Si compilamos y ejecutamos el código anterior, esto produciría el siguiente resultado −

7
hello
Exception: Stack<>::pop(): empty stack