Limiter les types des paramètres templates?

Salut!:D

Est-il possible de limiter les types des paramètres template afin d'éviter des incohérences?
Par exemple une fonction qui renverrait un nombre au hasard avec en paramètre template le type du nombre retourné:

Code:

---

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

#include <iostream>   using namespace std;   template<typename T> T f(){ return static_cast<T>(rand()%10+1); }   int main () { srand(time(NULL)); int n1=f<int>(); double n2=f<double>(); system("pause"); }

---

Comment limiter la spécialisation aux types "int", "double" ... en empêchant une éventuelle spécialisation vers un type "vector" par exemple?

Merci.:D

A ma connaissance, on ne peut pas :(

Une méthode serait de créer une classe de trait pour chaque type accepté:

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

#include <iostream>   using namespace std;   template<typename> struct f_trait{};   template<> struct f_trait<int>{ typedef int type; };   template<> struct f_trait<double>{ typedef double type; };     template<typename T> T f(){ typedef typename f_trait<T>::type type_T; return static_cast<type_T>(rand()%10+1); }     int main () { srand(time(NULL)); int n1=f<int>(); double n2=f<double>(); system("pause"); }

---

ce qui provoque une erreur de compilation si aucune spécialisation de la classe de trait n'existe pour le type template "T"; mais cela oblige à écrire toutes les spécialisations de la classe de trait; et rien n'empêche de créer une spécialisation de la classe de trait pour un type "vector".

Voir boost.type_traits, en particulier is_arithmetic

C'est vrai qu'on peut empêcher l'instanciation d'un template de cette manière.
Avec un mpl::if<> où on impose que le type soit arithmétique, la fonction ne renvoie pas de type de retour par ex et donc ne sera pas utilisée par le compilateur et à la fin on empêche d'utiliser avec certains types. Bien vu ;) J'avais oublié ce petit truc :D

En effet ça fonctionne:

Code:

---

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

#include <iostream> #include <boost/utility/enable_if.hpp> #include <boost/type_traits/is_arithmetic.hpp>   using namespace std;   template<typename T> typename ::boost::enable_if< ::boost::is_arithmetic<T>,T >::type f(){ return static_cast<T>(rand()%10+1); }     int main () { srand(time(NULL)); int n1=f<int>(); double n2=f<double>(); system("pause"); }

---

Merci.

Pour une solution future (en 2009 j'espère) et plus évoluée, et par pure curiosité, tu peux lire les papiers sur les concepts sur le site du standard C++.

Ok, c'est noté.
Sinon comment fait "Boost" pour obtenir ce résultat?
Est-ce basé sur les classes de traits?

Oui, pour certaines fonctions, c'est des classes de traits spécialisées, pour d'autres, ça dépend du compilateur, tout est indiqué dans la doc associée ;)

Il y a aussi utilisation intensive du SFINAE -- je vous laisse googler pour plus d'infos sur le fonctionnement, ou vous référer au modern C++ Design