C++-sjablonen

Sjablonen vormen de basis van generieke programmering, waarbij code wordt geschreven op een manier die onafhankelijk is van een bepaald type.

Een sjabloon is een blauwdruk of formule voor het maken van een generieke klasse of functie. De bibliotheekcontainers zoals iterators en algoritmen zijn voorbeelden van generieke programmering en zijn ontwikkeld met behulp van een sjabloonconcept.

Er is een enkele definitie van elke container, zoals vector , maar we kunnen veel verschillende soorten vectoren definiëren, bijvoorbeeld vector of vector .

U kunt sjablonen gebruiken om zowel functies als klassen te definiëren, laten we eens kijken hoe ze werken −

Functiesjabloon

De algemene vorm van een sjabloonfunctiedefinitie wordt hier getoond −

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

Type is hier een tijdelijke aanduiding voor een gegevenstype dat door de functie wordt gebruikt. Deze naam kan gebruikt worden binnen de functiedefinitie.

Het volgende is het voorbeeld van een functiesjabloon die het maximum van twee waarden retourneert −

#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;
}

Als we bovenstaande code compileren en uitvoeren, zou dit het volgende resultaat opleveren −

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

Klassjabloon

Net zoals we functiesjablonen kunnen definiëren, kunnen we ook klassensjablonen definiëren. De algemene vorm van een generieke klasseverklaring wordt hier getoond −

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

Hier, typ is de naam van het type tijdelijke aanduiding, die wordt opgegeven wanneer een klasse wordt geïnstantieerd. U kunt meer dan één generiek gegevenstype definiëren door een door komma's gescheiden lijst te gebruiken.

Hieronder volgt het voorbeeld om de klasse Stack<> te definiëren en generieke methoden te implementeren om de elementen van de stapel te pushen en eruit te halen −

#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;
   } 
} 

Als we bovenstaande code compileren en uitvoeren, zou dit het volgende resultaat opleveren −

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