syntaxe template spécialisation

Bonjour,

en me balladant dans du code boost, je suis tombé sur cette syntaxe :

Code:

---

1 2 3 4 5 6

template< typename T, std::size_t sz > struct range_const_iterator< T[sz] > { typedef const T* type; };

---

j'étais habitué à voir soit :

Code:

---

1 2 3 4 5 6

template< typename T, std::size_t sz > struct range_const_iterator { typedef const T* type; };

---

soit ça :

Code:

---

1 2 3 4 5 6

template< > struct range_const_iterator< T[sz] > //hummm.. finalement me parait pas terrible :) { typedef const T* type; };

---

A y réfléchir, on essaye ici de spécialiser les deux paramètres "en même temps"... sans doute dû à ça
Une explication plus fiable ?
merci

La première est une spécialisation partielle. La deuxième est impossible mais dans l'idée c'est une spécialisation totale.

Avec un example plus simple :

Citation:

---

template <typename T> //générique
struct bar
{};

template <typename T> //partielle
struct bar<T*>
{};

template <> //totale
struct bar<int>
{};

---

Code:

---

1 2 3 4 5

template< typename T, std::size_t sz > struct range_const_iterator< T[sz] > { typedef const T* type; };

---

si c'est partielle, dans quel cas le compilateur n'instanciera pas cette template?
a partir du moment on où écrit range_const_iterator<Foo,3>, j'ai l'impression que la template sera systématiquement instancié, non ?

Citation:

---

Envoyé par guillaume07

Code:

---

1 2 3 4 5

template< typename T, std::size_t sz > struct range_const_iterator< T[sz] > { typedef const T* type; };

---

si c'est partielle, dans quel cas le compilateur n'instanciera pas cette template?
a partir du moment on où écrit range_const_iterator<Foo,3>, j'ai l'impression que la template sera systématiquement instancié, non ?

---

non, ce n'est pas parce que y a deux paramnetre qu'il en faut deux. Cette specialisation est appellée pour range_const_iterator<Foo[3]>

Tu avais déjà vu ce genre de spécialisation partielle, puisque j'avais écrit un code avec ce genre de spécialisation dans un fil de discussion que tu avais ouvert : http://www.developpez.net/forums/d10...lt_of-functor/

Citation:

---

a partir du moment on où écrit range_const_iterator<Foo,3>, j'ai l'impression que la template sera systématiquement instancié, non ?

---

Le compilateur n'essaie pas de matcher la lste mais ce qui est dans la déclaration (pour les spécialisation, sinon en effet c'est la liste des paramètres (*) ), donc c'est :

Code:

---

1 2 3 4

range_const_iterator<Foo[3]> //et pas range_const_iterator<Foo,3>

---

(*) Qui dans ce cas n'aurait qu'un paramètre et pas deux :

Code:

---

1 2 3 4 5 6 7 8

template<class T> struct range_const_iterator; //Le fait de faire une simple déclaration sans définition permet d'interdire l'instancation d'autre chose qu'une spécialisation (partielle ici)   template<class T, size_t N> struct range_const_iterator<T[N]> { /*code*/ };

---

Le nombre de paramètres de la liste pour la spécialisation n'importe pas, ce qui compte c'est que le nombre de paramètre dans la déclaration (<T[N]>, donc 1), soit le même que le nombre de paramètre de la liste de paramètre de la déclaration du template (à comprendre pas la spécialisation) ( template<class T> struct ..., donc 1 )

j'aurais appris quelquechose ;)
thanks