C ++ template

Vorlagen sind generische Programmierung, generische Programmierung, die eine eigenständige Art und Weise auf eine bestimmte Art von Code zu schreiben ist.

Vorlage zu erstellen eine generische Klasse oder Funktion Bauplan oder Formel. Bibliothekscontainer, Iteratoren und Algorithmen sind beispielsweise Beispiele für generische Programmierung, sie alle verwenden das Konzept der Vorlagen.

Jeder Behälter hat eine einzige Definition, wieVektoren, können wir eine Reihe von verschiedenen Arten von Vektoren, wie vector <int>odervector <string> definieren.

Sie können Vorlagen verwenden, um die Funktionen und Klassen zu definieren, lassen Sie uns einen Blick darauf werfen, wie zu bedienen.

Funktionsschablone

Die allgemeine Form der Template-Funktion ist wie folgt definiert:

template <class type> ret-type func-name(parameter list)
{
   // 函数的主体
}  

Hier Typ ist eine Funktion der Datentypen Platzhalter Namen verwendet. Der Name kann in der Funktionsdefinition verwendet werden.

Hier ist ein Beispiel für eine Funktionsvorlage gibt die maximal mögliche Anzahl von zwei Arten:

#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 der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:

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

Vorlage Klasse

Wie wir Funktionsschablonen definieren, können wir die Klassenvorlagen definieren. Die allgemeine Form einer generischen Klassendeklaration ist wie folgt:

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

Hier Typ ist ein Platzhalter Typname kann in der Klasse angegeben werden instanziiert.Sie können eine durch Kommata getrennte Liste verwenden, um mehrere generische Datentypen definieren.

Das folgende Beispiel definiert eine Klasse Stapel <>, und implementiert die generische Ansatz Pop-Operationen auf Elemente zu stapeln:

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

using namespace std;

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

  public: 
    void push(T const&);  // 入栈
    void pop();               // 出栈
    T top() const;            // 返回栈顶元素
    bool empty() const{       // 如果为空则返回真。
        return elems.empty(); 
    } 
}; 

template <class T>
void Stack<T>::push (T const& elem) 
{ 
    // 追加传入元素的副本
    elems.push_back(elem);    
} 

template <class T>
void Stack<T>::pop () 
{ 
    if (elems.empty()) { 
        throw out_of_range("Stack<>::pop(): empty stack"); 
    }
	// 删除最后一个元素
    elems.pop_back();         
} 

template <class T>
T Stack<T>::top () const 
{ 
    if (elems.empty()) { 
        throw out_of_range("Stack<>::top(): empty stack"); 
    }
	// 返回最后一个元素的副本 
    return elems.back();      
} 

int main() 
{ 
    try { 
        Stack<int>         intStack;  // int 类型的栈 
        Stack<string> stringStack;    // string 类型的栈 

        // 操作 int 类型的栈 
        intStack.push(7); 
        cout << intStack.top() <<endl; 

        // 操作 string 类型的栈 
        stringStack.push("hello"); 
        cout << stringStack.top() << std::endl; 
        stringStack.pop(); 
        stringStack.pop(); 
    } 
    catch (exception const& ex) { 
        cerr << "Exception: " << ex.what() <<endl; 
        return -1;
    } 
}  

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:

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