Spécialisation de template

Bonjour, j'aimerais votre avis car je ne sais pas comment spécialiser une classe à l'intérieur d'un classe elle même template, sur g++ :

Code:

---

1 2 3 4 5 6 7

template<typename T> struct Foo { template<typename U> void f() { /* Plein de code ici... */ }   };

---

Comment faire ici pour spécialiser la fonction A::f() pour les int par exemples? Car si je le fais à l'intérieur de la classe j'ai une erreur de g++ qui dis que c'est impossible "error: invalid explicit specialization before '>' token" et je trouve pas de solution.

Et je n'arrive pas à le faire en dehors de la classe.

Merci d'avance ppour votre aide!

Bonjour,
Si tu veux seulement spécialiser la fonction template en gardant le patron de classe généralisé, ce n'est pas possible.
Il faut que tu spécialise ta classe dans laquelle tu pourras spécialiser à son tour la méthode : exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

#include <iostream>   using namespace std ;   template <typename T> struct foo { template <typename U> static void bar () ; };   template<> template <> void foo<float>::bar<int> () { cout << "float, int" << endl ;}   template <> template <> void foo<double>::bar<float> () { cout << "double, float" << endl ;} int main () { foo<float>::bar<int>() ; foo<double>::bar<float> () ; cout << "zou !" << endl ; }

---

Code:

---

1 2 3 4 5

float, int double, float zou ! Press any key to continue . . .

---

(efface, efface, efface)

Regis a répondu avant moi.

Tu peux faire un peu plus fun cependant : si f() appelle une fonction statique dans une classe template, cette classe peut être spécialisée selon le paramètre template de f().

Exemple :

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

#include <iostream>   namespace details { template <class U> struct Fimpl { static void impl() { std::cout << "non spécialisé" << std::endl; } };   template <> struct Fimpl<int> { static void impl() { std::cout << "<int>" << std::endl; } }; }   template <class T> struct A { template <class U> void f() { details::Fimpl<U>::impl(); } };   int main() { A<float>().f<char>(); A<float>().f<int>(); }

---

C'est la technique que j'utilise pour spécialiser partiellement les méthodes (puisque ce n'est pas censé être possible).

très joli emmanuel ;)

merci c'est bien les astuces auquel je ne pouvais pas penser :)

En tout cas merci beaucoup à vous deux!

Citation:

---

Envoyé par Emmanuel Deloget

[...]

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

#include <iostream>   namespace details { template <class U> struct Fimpl { static void impl() { std::cout << "non spécialisé" << std::endl; } };   template <> struct Fimpl<int> { static void impl() { std::cout << "<int>" << std::endl; } }; }   template <class T> struct A { template <class U> void f() { details::Fimpl<U>::impl(); } };   int main() { A<float>().f<char>(); A<float>().f<int>(); }

---

C'est la technique que j'utilise pour spécialiser partiellement les méthodes (puisque ce n'est pas censé être possible).

---

Ici, il y a un problème: la méthode spécialisée n'a pas accès aux paremètre template parent (ie celui de la classe A).

il faudrait probablement donner deux paramètres à U et utiliser une spécialisation partielle pour obtenir un résultat similaire à une spécialisation partielle de méthode.

Citation:

---

Envoyé par victor_gasgas

merci c'est bien les astuces auquel je ne pouvais pas penser :)

En tout cas merci beaucoup à vous deux!

---

noublie pas la balise :resolu: ;)

Oui oui j'oublie jamais la balise résolu en temps normal, mais je suis bien confronté au problème que tu cites à savoir ne pas avoir accès au paramètres templates de l'appelant.

Et je n'arrive pas à mettre en œuvre t'as dernières techniques énoncer.

Je sais que j'en demande un peu beaucoup mais la métaprog. reste encore obscure pour moi. Encore merci.

en reprennant le code d'Emmanuel Deloget, on obtient ça:

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

#include <iostream> #include <typeinfo>   namespace details { template <class T,class U> struct Fimpl { static void impl() { std::cout << "non spécialisé" << std::endl;} };   template <class T> struct Fimpl<T,int> { static void impl() { std::cout << "<int>" << std::endl; std::cout << "le deuxieme type est " <<typeid(T).name()<<std::endl; } }; }   template <class T> struct A { template <class U> void f() { details::Fimpl<T,U>::impl(); } };   int main() { A<double>().f<char>(); A<double>().f<int>(); }

---

voilà :)

bonne chance pour la suite ;)

Merci beaucoup c'est exactement ce qu'il me fallait :)

Bonne journée à tous!

Citation:

---

Envoyé par méphistopheles

Ici, il y a un problème: la méthode spécialisée n'a pas accès aux paremètre template parent (ie celui de la classe A).

il faudrait probablement donner deux paramètres à U et utiliser une spécialisation partielle pour obtenir un résultat similaire à une spécialisation partielle de méthode.

---

Judicieux ! Je n'y avait pas pensé, mais c'est vrai que c'est très logique :)