C de résumé du modèle

modèle de fonction

Nous pouvons fonctionnons modèle en fonction spéciale à l' intérieur du type de paramètre peut être de tout type , de sorte que nous pouvons réduire les doubles emplois définis, de sorte que le modèle de fonction adapter automatiquement aux différents types de paramètres, qui peuvent accueillir une variété de fonctions types de paramètres, par exemple double, intou quelle classe.

C ++ afin d'atteindre les fonctions ci - dessus, l'introduction de templatece concept. Nous pouvons en tant que modèle est un type spécial de paramètres, et peut également être passé en paramètre dans une fonction, cœur à l' intérieur comme intce qui est sur la ligne.

Les paramètres de type déclarés format de modèle de fonction est la suivante :

template <class identifier> function_declaration;
template <typename identifier> function_declaration;    // 这里使用了typename 当做声明类型参数

La fonction de modèle de format de déclaration ci - dessus est seulement une différence, qui est class, et typename, en fait, ici ne fait aucune différence ce genre d'utilisation, ils aiment voir sur la ligne, C ++ n'a pas fait cette distinction stricte;

Afin de mieux illustrer comment utiliser le modèle de fonction, lui donner un exemple très vive de qui est une fonction qui retourne une valeur plus grande, le libellé spécifique comme suit:

template <typename T>
T GetMax(T a, T b)
    return a > b ? a : b;

Dans ce qui précède quelques lignes de code que nous avons créé une fonction de modèle est utilisé pour obtenir le nombre plus grand entre les deux nombres, ne facile de voir T ici spécifie pas un type particulier, dans lequel nous pouvons encore dans mon coeur le considérer comme un traitement de variable ordinaire, la valeur de retour est T.

Pour utiliser nos définitions de fonction de modèle, référence peut être fonction format modèle d'appel unifié:

 function_name<type> (parameters);    // type就是具体的类型，例如int、double这些，parameters就是函数里的参数，也是具体类型

Donc, si nous voulons atteindre l' accès à deux grandes valeur entière, nous pouvons passer ce type int après avoir appelé la GetMaxfonction, des exemples spécifiques sont les suivants:

int x = 4;
int y = 2;

int max = GetMax<int> (x, y);    // max = 4

modèle de classe

En raison du type de déclaration de modèle peut être de tout type , qui est, lors de l' utilisation des types spécifiques de la ligne d' arrivée. Donc , vous pouvez vous référer aux exemples de configuration de modèle de fonction ci - dessus du modèle de classe est le même, passant des variables spécifiques lors de l' utilisation de ce type de classe sur la ligne. Par exemple, la définition du modèle de classe suivante:

template <typename T>
class MyPair{
    T value[2];
    
    public:
        MyPair(T first, T second)
        {
            value[0] = first;
            value[1] = second;
        }
  };

définition échantillon de classe de code d'un modèle de MyPairclasse, pour le stockage de tout type de deux éléments , par exemple double, char, intcomme, deux exemples sont donnés ci - dessous I, sont stockées double, et intune variable de type

MyPair<int> myInt(2, 3);    // 存储两个整型值
MyPair<double> myDouble(2.3, 3.43);    // 存储两个double值

fonctions membres de la classe de modèle peuvent être définis en dehors de la classe écriture, et un modèle de fonction d'écriture est le même, l'exemple spécifique est illustré ci - dessous:

template <class T>
class MyPair {
    T a, b;
  public:
    mypair (T first, T second)
      {a=first; b=second;}
    T Getmax ();
};

template <typename T>
T MyPair<T>::Getmax ()    // 在类外定义函数， 注意前面的写法和函数模板写法一致
{
  T retval;
  retval = a>b? a : b;
  return retval;
}

spécialisation modèle

Si nous voulons modèle de classe est défini comme une implémentation différente de l'interface, et nécessite des paramètres de spécifiques doivent être passé en paramètre, alors nous pouvons être la spécialisation de modèle ;

Pour mieux illustrer la spécialisation de modèle, ou donner un exemple simple. Supposons que nous définissons une classe mycontainer, la classe peut être stockée dans un type d'une variable, et cette classe il y a une fonction appelée increasementpour ajouter un type de stockage. Et si cette classe stocke est un type de char, nous trouvons cette classe pour mettre en œuvre pour convertir l' une des variables membres à la fonction majuscule sera plus pratique, il est peut - être cette fonction est définie ToUpper, afin que nous puissions être de type char réaliser modèle de modèle de classe de spécialisation, le code des exemples spécifiques est la suivante:

// 模板特化
#include <iostream>
using namespace std;

// 声明类模板:
template <typename T>
class mycontainer {
    T element;
  public:
    mycontainer (T arg) {element=arg;}
    T increase () {return ++element;}
};

// char类型的模板特化:
template <>
class mycontainer<char> {
    char element;
  public:
    mycontainer(char arg) {element=arg;}
    
    char ToUpper()
    {
      if ((element>='a')&&(element<='z'))
      element+='A'-'a';
      return element;
    }
};

Pour le modèle spécial ci - dessus, nous avons besoin de points, attention à des modèles de classe et spécialisation du modèle des différences et des connexions :

• Devant le modèle de classe en plus template <>, ce qui indique une spécialisation de modèle, c'est - à - dire le besoin de spécialisation de modèle pour ajouter cette phrase;
• Un autre point est que derrière l'utilisation du modèle de classe <char>paramètres, ce paramètre particulier représente la spécialisation de classe de modèle que nous roulions le <char>type;

D'autres utilisations du modèle

En plus templateou en classplus du paramètre du modèle indique le type du début de la déclaration de mots - clés, modèle peut aussi avoir d' autres types de paramètres, par exemple int, doubleces paramètres, semblables à une fonction avec plusieurs paramètres, chaque type de paramètre n'est pas la même chose. Afin de mieux illustrer d' templateautres utilisations, il peut se référer à l'exemple de code suivant,

#include <iostream>
using namespace std;

template<class T, int N>    // 这里除了含有class声明的类型之外，还拥有一个int类型
class mysequence {
    T memblock [N];
  public:
    void setmember(int x, T value);
    T getmember(int x);
};

template<class T, int N>
void mysequence<T,N>::setmember(int x, T value) {
  memblock[x]=value;
}

template<class T, int N>
T mysequence<T,N>::getmember(int x) {
  return memblock[x];
}

int main(){
  mysequence<int,5> myints;
  mysequence<double,5> myfloats;
  myints.setmember(0,100);
  myfloats.setmember(3,3.1416);
  cout << myints.getmember(0) << '\n';
  cout << myfloats.getmember(3) << '\n';
  return 0;
}