La différence entre l'instanciation et la spécialisation dans les modèles c++

4 concepts:

(implicite) de l'instanciation de: c'est ce que vous appelez l'instanciation

instanciation explicite:: c'est quand vous dites que le compilateur pour instancier le modèle avec les types de donnée, comme ce

template Struct<char>; //used to control the PLACE where the template is inst-ed

(explicite )spécialisation: c'est ce que vous vous référez à la spécialisation

partielle spécialisation c'est lorsque vous donnez une définition alternative à un modèle pour un sous-ensemble de types, comme ceci:

template<class T> class Struct<T*> {...} //partial specialization for pointers

Un modèle de spécialisation de modifier le comportement du modèle pour un type spécifique. par exemple convertir une chaîne de caractères:

template<typename T> std::string convertToString( const T& t )
{
   std::ostringstream oss;
   oss << t;
   return oss.str();
}

Nous allons spécialiser que si, lors de notre type est déjà un std::string comme il est inutile de passer par ostringstream

template<> std::string convertToString( const std::string & t )
{
   return t;
}

Vous pouvez spécialiser pour les classes trop.

Maintenant instanciation: ceci est fait pour vous permettre de déplacer la compilation de certains types dans une unité de compilation. Cela peut vous faire économiser le temps de compilation et parfois, le code-ballonnement de trop.
Disons que nous avons faites ci-dessus dans une classe appelée StringConvert plutôt qu'une fonction.

template<typename T>
class StringConvert
{
 public:
  //4 static functions to convert from T to string, string to T,
   //T to wstring and wstring to T using streams
 };

Nous allons convertir un lot de nombres entiers pour les chaînes de sorte que nous pouvons instancier: Mettre cela à l'intérieur d'un en-tête

 extern template class StringConvert<int>;

Mettre cela à l'intérieur d'une unité de compilation:

 template class StringConvert<int>;

Remarque que ci-dessus peut également être fait (sans le extern dans l'en-tête) avec des fonctions qui ne sont pas réellement mis en œuvre sur la ligne. L'une de vos unités de compilation permettra de les mettre en œuvre. Cependant, alors votre modèle est limitée à instancié types. Parfois lorsque le modèle a un destructeur virtuel.

En c++ 11.

instanciation:

Instancier le modèle avec modèle donné des arguments

template <typename T>
struct test{ T m; };

template test<int>;//explicit instantiation

qui aboutissent à une définition d'une structure avec un identificateur de test<int>

test<int> a;//implicit instantiation

si template <typename T> struct test a été instancié avec l'argument T = int avant(explicite ou implicite), puis c'est juste une structure de l'instanciation. Sinon, il va instancier template <typename T> struct test avec l'argument T = int première implicitement et puis instancier une instance de struct test<int>

spécialisation:

une spécialisation est encore un modèle, vous avez encore besoin d'instanciation pour obtenir le code réel.

template <typename T>
struct test{ T m; };
template <> struct test<int>{ int newM; } //specialization

La plus utile de spécialisation de modèle, c'est probablement que vous pouvez créer différents modèles pour différents modèle arguments qui signifie vous pouvez avoir des définitions différentes de la classe ou de fonction pour les différents arguments de modèle.

template<> struct test<char>{ int cm; }//specialization for char
test<char> a;
a.cm = 1;

template<> struct test<long> { int lm; }//specialization for long
test<long> a;
a.lm = 1;

En plus de ces modèle complet de spécialisations ci-dessus, il y a(seulement modèle de classe) sorties partielle du modèle de spécialisation aussi.

template<typename T>
struct test {};
template <typename T> struct test<const T>{};//partial specialization for const T


template <typename A, typename B>
struct test {};
template <typename B> struct test<int, B>{};//partial specialization for A = int