C de la matrice

Les modèles sont la programmation générique, programmation générique qui est une manière autonome à un type particulier de l'écriture de code.

Modèle pour créer une classe ou d'une fonction modèle ou une formule générique. conteneurs bibliothèque, itérateurs et algorithmes, par exemple, sont des exemples de programmation générique, ils utilisent tous le concept de modèles.

Chaque conteneur a une définition unique, tels que desvecteurs, on peut définir un certain nombre de différents types de vecteurs, tels que vector <int>ouvecteur <string>.

Vous pouvez utiliser des modèles pour définir les fonctions et les classes, nous allons jeter un oeil à la façon d'utiliser.

modèle de fonction

La forme générale de la fonction de modèle est défini comme suit:

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

Ici, le type est fonction des types de données utilisés pantonymie. Le nom peut être utilisé dans la définition de fonction.

Voici un exemple d'un modèle de fonction retourne le nombre maximal de deux types:

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

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:

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

modèle de classe

Comme nous définissons des modèles de fonction, nous pouvons définir les modèles de classe. La forme générale d'une déclaration de classe générique est la suivante:

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

Ici, le type est un nom de type d'espace réservé peut être spécifié dans la classe est instancié.Vous pouvez utiliser une liste séparée par des virgules pour définir plusieurs types de données génériques.

L'exemple suivant définit une classe Stack <>, et met en œuvre l'approche générique pour empiler les opérations de pop sur des éléments:

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

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:

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