Discussion :

[guillaume07]

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
    template< typename T, std::size_t sz >
    struct range_const_iterator
    {
        typedef const T* type;
    };

soit ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Goten]

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 :

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

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

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

[guillaume07]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[Joel F]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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]>

[Flob90]

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/

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 )

[guillaume07]

j'aurais appris quelquechose
thanks