Déduction de type pour methode statique d'une classe template

Version imprimable

Bonjour,

J'ai besoin de définir des méthodes statiques templates qui utilisent le scope d'une classe template et dont les parametres sont déduis à la compilation. Illustration :
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 template <typename T> class type { public: template<typename U> static type operation(const type& x, const type& y) { // par exemple return x.a*y.a; } T a; }; // et un appel type<float> a = 5.0f; type<float> b = 4.0f; type<float> c = type::operation(a,b); // c = 20.0f // et non (comme le voudrais g++) type<float> c = type<float>::operation(a,b); // c = 20.0f // ou encore type<int> c = type<float>::operation(a,b); // c = 20.0f // etc ...
Le scope est important, je ne veux pas définir ce type de methode a l'extérieur de la classe. Est ce que c'est réalisable ? Si oui comment ?

Merci d'avance !

Ce que tu souhaites faire est tout fait valide. La preuve en image :

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 <typeinfo>
 
template <typename T>
class type
{
public:
  type(const T& v) : a(v) { }
 
   template<typename U>
   static type<U> operation(const type<U>& x, const type<U>& y)
   {
      // par exemple
      return type<U>(x.a*y.a);
   }
 
   T a;
};
 
void test()
{
  type<float> a(2.0f), b(3.0f);
 
  std::cout << "type<int> " << typeid(type<int>).name() << std::endl;
  std::cout << "type<???> " << typeid(type<int>::operation(a, b)).name() << std::endl;
}
 
int main()
{
  test();
}

Compilé avec g++, on récupère :

Code:

1
2
3
 
type<int> 4typeIiE
type<???> 4typeIfE

operation() a bien reconnu des type<float>, et a bien renvoyé un type<float> 4typeIfE au lieu de 4typeIiE pour un type<int>)

01/12/2010, 18h38
blitz_

Non, j'ai du mal me faire comprendre.

Je ne veux pas spécifier le type template quand j'appelle la méthode statique.
Je veux
type::operation(a,b)
et non pas :
type<T>::operation(a,b), pour T quelconque

Si ma classe de base n'était pas une classe template, ca marcherai, le compilateur arrive à déduire le type avec les paramètres, mais dans mon cas il n'y arrive pas. Donc puis-je faire quelque chose pour y remédier ?

Bonjour

Tu peux toujours ajouter un paramètre par défaut pour ton template pour pouvoir l'appeler sans paramètre :
Code:

1 2 3 4 template <typename T = int> class type { ... }; type<float> c = type<>::operation(a,b);
Mais ça me semble pas être une bonne idée (tu crées une classe type<int> même si tu ne l'utilises pas)

La méthode que j'aurais utilisé est une fonction non membre, soit en utilisant une fonction membre publique :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 template <typename T = int> class type { ... type<T>& operation(const type<T>& y) { a *= y.a; return *this; } }; template<typename T> static type<T> operation(const type<T>& x, const type<T>& y) { type<T> x2(x); return x2.operation(y); }
soit en utilisant une fonction en amie :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 template <typename T = int> class type { ... template<typename U> friend type operation(const type& x, const type& y); }; template<typename U> static type operation(const type& x, const type& y) { return x.a * y.a; }

01/12/2010, 18h57
blitz_

Si j'ajoute une valeur par défaut pour le paramètre template, cela ne marche pas (toujours la même erreur de compilation g++ au passage : template<class T> class A used without template parameters)

Je suis d'accord, ca marche si j'utilise une fonction mais j'aimerai pouvoir acceder a la fonction via un operateur de scope (qui porte le nom de la classe template)...
01/12/2010, 19h10
gbdivers

Ça marche chez moi (par contre, il faut quand même ajouter les fonctions de conversion U -> type) (sous win7)

Citation:

Je suis d'accord, ca marche si j'utilise une fonction mais j'aimerai pouvoir acceder a la fonction via un operateur de scope (qui porte le nom de la classe template)...

Le problème est que même si c'est une fonction statique, tu n'as pas 1 fonction pour toutes tes spécialisations mais bien 1 fonction par spécialisation (imagine si tu utilisais le type T dans ta fonction, tu aurais bien 1 fonction par spécialisation ; le fait de ne pas utiliser le type T ne doit rien changer pour le compilateur : il créer plusieurs fonctions statiques différentes, je pense).

Les autres écritures que je t'ai proposé fonctionne.

Si le problème est la portée de ta fonction, utilise un espace de nom
01/12/2010, 20h50
blitz_

Citation:

Envoyé par gbdivers

Le problème est que même si c'est une fonction statique, tu n'as pas 1 fonction pour toutes tes spécialisations mais bien 1 fonction par spécialisation (imagine si tu utilisais le type T dans ta fonction, tu aurais bien 1 fonction par spécialisation ; le fait de ne pas utiliser le type T ne doit rien changer pour le compilateur : il créer plusieurs fonctions statiques différentes, je pense).

Oui, mais au final le type template de la méthode statique est indépendant de celui de la classe. On pourrait faire cela sur une classe non "templatée", alors pourquoi pas sur un template ? Dommage ... ^^

Citation:

Envoyé par gbdivers

Si le problème est la portée de ta fonction, utilise un espace de nom

Je pense que je vais passer par la, utiliser un namespace du genre type_operations::, a voir si c'est pas trop lourd à l'utilisation.

Merci en tout cas !
01/12/2010, 22h10
gl

Citation:

Envoyé par blitz_

Oui, mais au final le type template de la méthode statique est indépendant de celui de la classe. On pourrait faire cela sur une classe non "templatée", alors pourquoi pas sur un template ? Dommage ... ^^

Mais, comme précédemment expliqué par gbdivers, type<int> et type<float> sont deux types totalement différents (exactement comme si tu avais créé deux classes non template type1 et type2). Tu as donc deux fonctions membres de classes nommées operation() totalement distinctes. Et il faut bien fournir la classe à laquelle appartient la fonction (de la même manière qu'avec les classes non template tu aurais tu préciser laquelle utiliser).
En fait le type template U des paramètres de la fonction est bien déduis, c'est le type template T de la classe à laquelle appartient operation() qui ne l'est pas et ne peux pas l'être.

En fait ta comparaison avec la classe non template n'est pas bonne. La différence n'est pas d'avoir ou non un template, mais d'avoir une seule et unique classe ou plusieurs classes distinctes.

Citation:

Envoyé par blitz_

Je pense que je vais passer par la, utiliser un namespace du genre type_operations::, a voir si c'est pas trop lourd à l'utilisation.

Avoir nom_classe::operation ou nom_namespace::operation ne me semble pas très différent au niveau lourdeur d'utilisation.

par contre j'ai du mal à comprendre pourquoi tu cherches à designer ta classe de cette façon. Cela ne me semble pas de prime abord très sain.

Citation:

Envoyé par gl

par contre j'ai du mal à comprendre pourquoi tu cherches à designer ta classe de cette façon. Cela ne me semble pas de prime abord très sain.

Je développe une librairie de math, et j'aurai voulu pouvoir accéder aux opérations disponibles du type, en utilisant son scope. Pourquoi ?

Voila un type de base :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 template <typename T> class vec2 { public: // Produit scalaire template <typename U> static U dot(const vec2& x, const vec2& y) { return x.x*y.x + x.y*y.y; } T x; T y; };
Et voila comment j'aurai voulu m'en servir
Code:

1 2 3 4 5 6 // declaration (exemple entier short) vec2<int16> a(5, 6); vec2<int16> b(53, 16); // produit scalaire int16 dot_result = vec2::dot(a,b);
Je trouve que le code est assez clair comme ca, pratique dans un code assez important.

01/12/2010, 23h20
gl

Le problème c'est justement que le type est vec2<16> pas vec2. Donc le scope est vec2<16>::

Ce que tu cherches à faire se traduit généralement en C++ par une fonction non-membre, le tout (classes et fonctions) dans un namespace.

Au passage, je ne vois pas de gain de clarté apporté par la précision d'une éventuelle classe à laquelle appartiendrait l'opération. Le type des paramètres est lié aux paramètres et le "module" auquel appartient la classe est fournie par l'espace de nom, pas par le nom d'une classe. Mais ça reste assez subjectif comme point de vue.
Pour être plus précis, tu veux définir une fonction de classe non pas pour son rôle (elle n'a pas de raison conceptuelle d'être déclarée ainsi) mais pour un regrouper les éléments en un tout cohérent (ce qui est le but du namespace).
02/12/2010, 09h47
Emmanuel Deloget

Citation:

Envoyé par gl

Au passage, je ne vois pas de gain de clarté apporté par la précision d'une éventuelle classe à laquelle appartiendrait l'opération.

Je plussoie. Je pense que c'est de cette manière qu'il faut procéder. Il y a une paire d'année, une discussion proposant la création d'une librairie de math "standard" pour le C++ a emergé sur la mailing list sweng-gamedev (je n'arrive pas à retrouver le thread en question, mais une recherche un peu poussée devrait te le permettre). Les fonctions libres (dot, cross, ...) étaient l'une des solutions proposées pour le design de cette librairie (en fait, c'était la solution qui a reçu le plus de support, par rapport à des fonctions membres où à des redéfinitions d'opérateurs).

Et je rajoute le fait que dès que tu déclare une classe template, tu peux la spécialiser. Cette spécialisation, même si elle n'existe pas dans ta librairie, peut exister par ailleurs (être définie par exemple dans le code client de la librairie).

Par conséquent, l'existence de type<float>::operation() n'entraine pas l'existence de type<int>::operation(). Du coup, on voit mal comment le compilateur pourrait permettre un accès à une fonction type::operation() dont l'existence n'est pas garantie.
02/12/2010, 10h19
gl

Citation:

Envoyé par Emmanuel Deloget

Et je rajoute le fait que dès que tu déclare une classe template, tu peux la spécialiser. Cette spécialisation, même si elle n'existe pas dans ta librairie, peut exister par ailleurs (être définie par exemple dans le code client de la librairie).

Et réciproquement, l'utilisation d'une fonction libre template permet de spécialiser cette fonction pour un type donnée indépendamment de la spécialisation de la classe.
02/12/2010, 11h36
blitz_

Citation:

Envoyé par Emmanuel Deloget

Par conséquent, l'existence de type<float>::operation() n'entraine pas l'existence de type<int>::operation(). Du coup, on voit mal comment le compilateur pourrait permettre un accès à une fonction type::operation() dont l'existence n'est pas garantie.

Oui, je pensais qu'étant donné que la fonction ne dépendait pas du type template, il y avait peut être un moyen de s'en sortir.

Tout est clair pour moi, merci pour ces explications/clarifications :)

Fuseau horaire GMT +2. Il est actuellement 21h53.