specialisation explicite de patron de fonction avec des parametres de patron non-typé

Bonjour,

voici ma définition de patron générique :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template <class Type, int size> int count( Type ( &array )[ size ], Type value ) { int count_value = 0; for( int i = 0; i < size; ++i ) if( array[ i ] == value ) ++ count_value;   return count_value; }

---

Ce patron compile bien.

Je souhaiterais réaliser aussi une spécialisation explicite de ce patron pour le
paramètre de patron Type : const char * .

Voici ce que j'écris dessous :

Code:

---

1 2 3 4 5 6 7 8 9 10

typedef const char *PCC; template<> int count< PCC , int size >( PCC ( &array )[ size ], PCC value ) { int count_value = 0; for( int i = 0; i < size; ++i ) if( strcmp( array[ i ], value ) == 0 ) ++ count_value;   return count_value; }

---

Malheureusement quand je compile, j'ai deux erreurs pour le patron
spécialisé.
-> syntax error : missing ',' before identifier 'size'
-> 'size' : undeclared identifier

Cela concerne la ligne :

Code:

---

template<> int count< PCC , int size >( PCC ( &array )[ size ], PCC value )

---

Je n'arrive donc pas à écrire convenablement une spécialisation explicite de
patron de fonction contenant des paramètres de patron non-typé :
ici 'int size' .

Je n'ai pas trouvé de réponse sur internet . Quelqu'un sait-il comment faire ?

Merci d'avance.

Tu te trompe légèrement sur le code à écrire pour une spécialisation :

Code:

---

1 2 3 4 5 6

template <int size> int count<PCC,size>(PCC ( &array )[ size ], PCC value ) { ... }

---

size reste un paramètre template non défini dans cette spécialisation.

Finalement j'ai réussi à compiler en écrivant ceci :

Code:

---

template<int size> int count( PCC ( &array )[ size ], PCC value )

---

Mais alors pourquoi ? mystère...

Citation:

---

Envoyé par clengrand

Finalement j'ai réussi à compiler en écrivant ceci :

########
template<int size> int count( PCC ( &array )[ size ], PCC value )
########


Mais alors pourquoi ? mystère...

---

Parce que tu as surchargé la fonction.

En fait là tu es en train de me dire que ça a compilé parce que finalement j'ai fait une surcharge de patron de fonction au lieu de faire une spécialisation explicite de mon patron générique , comme je voulais au départ ?

C'est bien ça?

Bonsoir,
C'est bien ça.

Code:

---

1 2 3 4 5

template <class Type, int size> int count( Type ( &array )[ size ], Type value );   template<int size> int count( PCC ( &array )[ size ], PCC value );

---

Ces deux fonctions ont le même nom, possèdent deux arguments de types identiques (enfin modulo la généricité), et ont le même type de retour.
Donc jusque là, elles sont identiques ; où plus exactement, la seconde est une spécialisation de la première.

La différence se situe au niveau des paramètres template : la première fonction en a deux, alors que la seconde n'en a qu'un.
On peut donc faire la différence entre les deux, et ainsi la seconde est une surcharge de la première, et pas une spécialisation.

Pour autant, le comportement sera le même.
Si l'on peut unifier les paramètres aux deux fonctions, c'est la seconde qui sera choisie, parce que plus spécifique (moins générique) que la première.

Pour spécialiser correctement une fonction, il faut l'indiquer explicitement lors de sa définition.
Comme l'a dit Emmanuel Deloget :

Code:

---

1 2 3 4 5

template <int size> int count<PCC,size>(PCC ( &array )[ size ], PCC value ) { ... }

---

En fait, les paramètres entre chevrons après le nom de la fonction sont implicite pour la version la plus générique d'un patron.

Sauf que la spécialisation partielle de fonction ca n'existe pas, donc la solution est bien la surcharge.

Citation:

---

Envoyé par Flob90

Sauf que la spécialisation partielle de fonction ca n'existe pas, donc la solution est bien la surcharge.

---

C'en est où, cette histoire, avec C++11, d'ailleurs ?

Ca n'a pas changé à ma connaisance.

Merci beaucoup pour vos aides respectives.

Grâce à vous j'ai compris.
Dans ma situation la seule solution est de faire une surcharge de patron dans le cas de l'utilisation de paramètres de patron non-typés, car actuellement la spécialisation partielle de patrons de fonctions n'est donc possible ?

A bientôt! ;)

Exact.