C++-Vorlagen

Vorlagen sind die Grundlage der generischen Programmierung, bei der Code unabhängig von einem bestimmten Typ geschrieben wird.

Eine Vorlage ist ein Entwurf oder eine Formel zum Erstellen einer generischen Klasse oder Funktion. Die Bibliothekscontainer wie Iteratoren und Algorithmen sind Beispiele für generische Programmierung und wurden unter Verwendung des Template-Konzepts entwickelt.

Für jeden Container gibt es eine einzige Definition, z. B. Vektor , aber wir können viele verschiedene Arten von Vektoren definieren, zum Beispiel Vektor oder Vektor .

Sie können Vorlagen verwenden, um sowohl Funktionen als auch Klassen zu definieren, lassen Sie uns sehen, wie sie funktionieren −

Funktionsvorlage

Die allgemeine Form einer Vorlagenfunktionsdefinition wird hier gezeigt −

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

Typ ist hier ein Platzhaltername für einen Datentyp, der von der Funktion verwendet wird. Dieser Name kann innerhalb der Funktionsdefinition verwendet werden.

Das Folgende ist das Beispiel einer Funktionsvorlage, die das Maximum von zwei Werten zurückgibt −

Live-Demo

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

Wenn wir den obigen Code kompilieren und ausführen, würde dies das folgende Ergebnis erzeugen −

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

Klassenvorlage

So wie wir Funktionsvorlagen definieren können, können wir auch Klassenvorlagen definieren. Die allgemeine Form einer generischen Klassendeklaration wird hier gezeigt −

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

Hier tippen ist der Platzhaltertypname, der angegeben wird, wenn eine Klasse instanziiert wird. Sie können mehr als einen generischen Datentyp definieren, indem Sie eine durch Kommas getrennte Liste verwenden.

Es folgt das Beispiel, um die Klasse Stack<> zu definieren und generische Methoden zu implementieren, um die Elemente vom Stack zu pushen und zu entfernen −

Live-Demo

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

Wenn wir den obigen Code kompilieren und ausführen, würde dies das folgende Ergebnis erzeugen −

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