Spécialisation d'une fonction template avec un argument template

Bonjour

j'ai une classe Job

Code:

---

template<typename T, int n> class Job;

---

et une fonction work

Code:

---

template<class T> void work(T & job);

---

Je voudrais spécialiser work pour la classe Job<T, 1> quelque soit T.

j'ai essayé toute une ribambelle de choses mais j'avoue que je m'y perds là :

Code:

---

1 2	template<> template<typename T> void work< Job<T, 1> >(Job<T, 1> & job); template<> void work< template<typename T> Job<T, 1> >(Job<T, 1> & job);

---

D'ailleurs est-ce que c'est possible ?

(Au passage c'est aussi difficile de trouver un titre à la discussion ...)

Merci.

Flo.

La spécialisation partielle de fonction libre est interdite.

C'est considéré comme une spécialisation partielle de fonction ? Pourtant c'est l'argument template qui est partiellement spécialisée par la finction elle-même ... Bon mais si tu le dis ...

Par ailleurs, je me rends compte que je ne sais pas comment traiter le cas pour une spécialisation totale de cette même fonction pour Job<T, n>. C'est à dire spécialiser work pour Job<T, n> quelque soit T et n.

Flo.

Je crois que tu te méprends sur la syntaxe des templates et la spécialisation.

La syntaxe de base est : template<parameters> declaration Ou parameters est la listes des paramètre templates et declaration respecte la même syntaxe qu'une déclaration classique en utilisant éventuellement les paramètres templates.

La spécialisation est une technique qui permet de donner une code spécifique pour des paramètres templates spécifique, elle est totales si tout les paramètres sont fixés.

Avec des exemples :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

//Declaration d'une fonction template template<class T> void foo(const T&) {/*code*/}   //Spécialisation totale pour int template<> void foo<int>(const int&) {/*autre code*/} //On voit ici que les paramètres sont fixé : <int>   //On peut aussi écrire (dans certains cas) template<> void foo(const int&) {/*autre code*/}

---

Une spécialisation partielle pour les fonctions serait (n'existe pas pour les fonctions)

Code:

---

1 2 3 4 5 6

template<class T> struct MyTemplateClass {};   template<class T> void foo<MyTemplateClass<T> >(const MyTemplateClass<T>&) {}

---

A noter qu'il me semble que la spécialisation totale de fonction est déconseillé et qu'on préfère déclarer une fonction non-template qui serait trouvé avant la fonction template lors de la recherche de l'identifiant. Par contre je n'ai pas l'explication du pourquoi. (Et je ne me souvient pas où j'ai lu ceci).

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template<class T> void foo(const T&) {/*code*/}   void foo(const int&) {/*autre code*/}   //On peut dans ce cas "optimiser" le type du paramètre void foo(int) {/*autre code*/}

---

Merci pour cette longue réponse ...

Non non je ne me méprends pas ... ;) (enfin je crois !)

Je veux une fonction libre templatée avec un fonctionnement générique et spécialiser son fonctionnement uniquement pour certaines valeurs de l'argument du template. Ce que je ne peux pas avoir avec une fonction libre non templatée.

Je veux une fonction libre pour pouvoir l'appeler de manière implicite (sans préciser l'argument du template). Et j'ai pas réussi à appeler une méthode statique non templatée de classe templatée de manière implicite.

Voilà, après c'est pas dit que c'était tout bien clair dans ma tête.

Flo.

Oui mais tu ne peux pas faire ceci comme ca. Une spécialisation totale (et on ne peut faire que ca pour des fonctions) c'est pour des types fixés, à partir du moment où tu dis pour tout les types de la forme MyTemplateClass<T>, ce n'est plus un type fixé.

Tu pourrais faire une surcharge de ta fonction template avec une autre fonction template :

Code:

---

1 2 3 4 5 6 7 8

template<class T> void foo(const T&) {/*Code*/}   template<class T> void foo(const MyTemplateClass<T>&) {/*Code*/}

---

Par contre fais attention, il y a des cas où ca ne marchera pas car il y aura ambiguité entre les deux surcharges et le compilateur n'arrivera pas à déterminer laquelle appeler (pas dans ton cas ceci dit).

Salut,

j'ai bien compris qu'il était pas possible de faire une spécialisation partielle sur une fonction libre templatée.

Je repose mon problème car je pense ne pas avoir été assez clair.

Je déclare et définis la fonction suivante :

Code:

---

1 2 3 4

template<class T> void foo(T & t) { /* comportement général*/ };

---

Une spécialisation de cette fonction avec T = int ça donne

Code:

---

1 2 3 4

template<> void foo<int>(int & t) { }

---

Si maintenant j'ai la classe suivante :

Code:

---

template<class U, int n> class MyClass{}

---

Est-ce que je peux faire une spécialisation de la fonction foo avec T = MyClass<U, n>

Code:

---

1 2 3 4

template<class U, int n> template<> void foo< MyClass<U, n> >(MyClass<U, n> & t) { U a = n; }

---

(C'est n'importe quoi et cela marche pas évidemment, c'est juste pour être plus clair)

Est-ce que cette chose rentre dans le cadre d'une spécialisation partielle ? Et si c'est possible comment faire ? Quelle est la syntaxe ?

Parce que dans mon cas la spécialisaton de foo est la même pour MyClass quelque soit U et n. Je voudrais m'épargner de récrire le même code pour les 3 spécialisations suivantes par exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

template<> void foo< MyClass<int, 1> >(MyClass<int, 1> & t) { int a = 1; }   template<> void foo< MyClass<char, 2> >(MyClass<char, 2> & t) { char a = 2; }   template<> void foo< MyClass<double, 3> >(MyClass<double, 3> & t) { double a = 3; }

---

(Là aussi c'est histoire d'être clair)

Par contre j'ai bien compris qu'on pouvait pas spécialiser foo en ne fixant qu'1 des 2 arguments du template du style :

Code:

---

1 2 3 4

template<class U> template<> void foo< MyClass<U, 2> >(MyClass<U, 2> & t) { U a = 2; }

---

Merci

Flo.

Relis mon dernier message, je te propose une solution, elle ne marche pas dans ton cas ? Si oui montre ton code.

Pour être clair, ce que dit Florian est d'utiliser la surcharge et non la spécialisation partielle (qui n'est de toute façon pas possible pour les fonctions libres).
Soit :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

#include <iostream> template<class T> void foo(T const& t) { std::cout<<"ceci est la version generale\n"; }     template<> void foo<int>(int const& t) { std::cout<<"ceci est une spécialisation totale\n"; }   template<class U, int n> class MyClass{};     template<class U, int n> void foo(MyClass<U, n> const& t) { std::cout<<"ceci est une surchage et non un spécialisation partielle\n"; }   template<class U> void foo(MyClass<U, 1> const& t) { std::cout<<"ceci est une autre surchage différentes des 2 précédentes\n"; }     int main() { foo(double()); foo(int()); foo(MyClass<int,3>()); foo(MyClass<int,1>());   return 0; }

---

produit :

Citation:

---

ceci est la version generale
ceci est une specialisation totale
ceci est une surchage et non un specialisation partielle
ceci est une autre surchage differentes des 2 precedentes

---

Ok merci à vous 2. Cette fois ci j'ai compris.

Désolé d'avoir été un peu dur à la détente.

Merci pour votre patience ...

Flo.