Meta-programation, template et cast implicite [Résolu]

[Awakening]

Bonjour,
Mon problème est à priori simple, si tant est qu'il ait une solution.
L'exemple qui suit n'est pas mon problème mais c'est le même raisonnement.

A partir de ces deux fonctions :

Code :

1
2
3
 
template <class T> inline float Sin(T a) { return sinf(a); } //fonction 1 renvoyant un float
template <class T> inline double Sin(T a) { return sin(a); } //fonction 2 renvoyant un double

Je veux trouver ces appelles à la compilation :

Code :

1
2
3
4
5
 
float fa = Math::Sin((double)1.0); //Utilisation de la fonction 1
float fb = Math::Sin((float)1.0); //Utilisation de la fonction 1
double da = Math::Sin((double)1.0); //Utilisation de la fonction 2
double db = Math::Sin((float)1.0); //Utilisation de la fonction 2

Mais l'ennuie c'est que le compilateur trouve une ambiguïté du à "l'autocasting" (coercition ?) float -> double, double -> float.

Il n'y aurait pas une solution simple et propre de clarifier ça pour le compilateur ? Merci.

[Bousk]

Bonjour,


essaye une syntaxe comme

Code :

1
2
3
4
float fa = Math::Sin<double>((double)1.0); //Utilisation de la fonction 1
float fb = Math::Sin<float>((float)1.0); //Utilisation de la fonction 1
double da = Math::Sin<double>((double)1.0); //Utilisation de la fonction 2
double db = Math::Sin<float>((float)1.0); //Utilisation de la fonction 2

qui devrait éviter toute embrouille du compilateur.

edit: voir ci-dessous

[Ekleog]

AMHA le problème vient de la définition de Sin.
En effet, la seule différence entre les deux définitions est le type de retour, qui n'entre pas en compte dans le choix d'une fonction.

Donc il faudrait remplacer par :

Code :

1
2
float Sin(float f) { return sinf(f); }
double Sin(double d) { return sin(d); }

Ou bien, si le but est d'apprendre la métaprog' :

Code :

1
2
template <typename T> T Sin(T t) { return sin(t); }
template <> float Sin<float>(float f) { return sinf(t); }

[Awakening]

D'abord merci à tous les deux.

Ensuite, j'affine mon problème (vous ne pensiez pas vous en sortir si facilement ?!). Je voudrais utiliser ça (à peu près pareil qu'au dessus).

Code :

1
2
3
4
5
6
float fa = Math::Sin((double)1.0); //Utilisation de la fonction 1
float fb = Math::Sin((float)1.0); //Utilisation de la fonction 1
double da = Math::Sin((double)1.0); //Utilisation de la fonction 2
double db = Math::Sin((float)1.0); //Utilisation de la fonction 2
float fc = Math::Sin((int)1.0); //Utilisation de la fonction 1
double dc = Math::Sin((int)1.0); //Utilisation de la fonction 2

Sans que j'aurais a définir la valeur du paramètre et la valeur de retour, manuellement. Ce que je voudrais éviter d'écrire, c'est ça :

Code :

1
2
3
4
5
6
7
8
Fonction : Math::Sin</*type paramètre*/,/*type retour*/>
 
float fa = Math::Sin<double,float>((double)1.0);
float fb = Math::Sin<float,float>((float)1.0);
double da = Math::Sin<double,double>((double)1.0);
double db = Math::Sin<double,float>((float)1.0);
float fc = Math::Sin<int,float>((int)1.0)
double dc = Math::Sin<int,double>((int)1.0);

Une idée ? Ou il faut que je revois ma fainéantise à la baisse ?

[Bousk]

Est-ce que ceci compilerait :

Code :

template< typename R, typename P> R Sin(P val) { return sin(val); }

Je n'ai pas de quoi tester.

Sinon, parce qu'il est pas dit que l'ambiguité ne resurgisse pas ( 2 fonctions ne peuvent pas différer par leur unique type de retour)

Code :

template< typename R, typename P> void Sin(P val, R& ret) { ret = sin(val); }

[Flob90]

Je vois pas la Meta-Prog dans ton code ...

La détermination automatique des paramètres template ne sert pas à grand chose ici. Si ton objectif est de créer des fonctions utilisant des algo plus ou moins performant selon la situation, il faut nécessairement que tu dises explictement quel précision tu veux.

Si ce n'est pas pour ca que tu as plusieurs version, quel est la raison ?

@Ekleog: Préfères la surcharge à la spécialisation des fonctions templates.

[Awakening]

Merci pour toutes ces réponses.

Si ce n'est pas pour ca que tu as plusieurs version, quel est la raison ?

Dans l'exemple que j'ai donné c'était simplement pour utilisé la double précision quand c'est nécessaire (qu'avec un double donc) et une simple précision pour tous les autres types. Tout ça en étant transparent, avec la même écriture.
N'étant pas encore à fond dans la meta-programmation je voulais savoir si c'était aussi puissant que ça. Apparemment pas puisque le type de retour ne semble pas être pris en compte dans le cas présent (float et double) où la conversion se fait automatiquement.

Je vois pas la Meta-Prog dans ton code ...

La meta-programmation n'englobe pas tout ce qui concerne l'écriture de classe/fonction que se "définisse" à la compilation ?

Merci encore pour vos réponses, ça m'a beaucoup aidé.

[Flob90]

Si la méta-prog est très puissante, mais ce n'est en aucun cas ce que tu fais, ni ce que tu as besoin. Des classes de traits (plus proche de la programmation générique que de la méta-prog) devraient te suffir.

Mais comment veux-tu que le compilateur sache avec quel précison calculé si tu ne lui dit pas.

Par contre si ta précision dépend de la précision du paramètre tu peux faire quelque chose comme :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
template<class T>
struct ReturnTrait;
 
template<class T>
typename ReturnTrait<T>::type sin(const T& t)
{ /*blabla*/ }
 
//Pour un paramètre simple précision :
template<>
struct ReturnTrait<float>
{ typedef float type; };
 
//Pour un paramètre double précision :
template<>
struct ReturnTrait<double>
{ typedef double type; };

En réalité dans ce cas on peut simplifer par :

Code :

1
2
3
4
 
template<class T>
struct ReturnTrait
{ typedef T type; };

Edit: Non, la génération de fonctions/classes à la compilation c'est de la programmation générique. La méta-prog c'est l'utilisation de ces techniques de programmation générique pour effectuer des "calcul" à la compilation : les fonctions se transforment en classes templates, les objets en types, ect.

[Ekleog]

Envoyé par Awakening

D'abord merci à tous les deux.

Ensuite, j'affine mon problème (vous ne pensiez pas vous en sortir si facilement ?!). Je voudrais utiliser ça (à peu près pareil qu'au dessus).

Code :

[...]

Il est impossible de choisir la fonction en fonction de son type de retour.
Donc non.

Envoyé par Flob90

[...]
@Ekleog: Préfères la surcharge à la spécialisation des fonctions templates.

D'où mon "Ou bien, si le but est d'apprendre la métaprog' :".
(D'ailleurs, j'ai fait le même abus de langage que Awakening ...)

[Klaim]

Au passage,

Code :

1
2
3
auto i = 1; // i est un int
auto j = 1.0; // j est un double
auto k = 1.0f; // k est un float

Ca simplifiera un peu ton écriture si tu es au courant des types des valeures litérales....

[Awakening]

J'aime ce forum !

On en apprend toujours plus que prévu.

Du coup la finalité pourrait se traduire par ça :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
template<class T>
struct ReturnTrait { typedef float type; }; //Simple précision par défaut
template<>
struct ReturnTrait<double> { typedef double type; }; //Double précision qu'avec les doubles.
 
template<class T>
inline typename ReturnTrait<T>::type Sin(const T& a) //Fonction 1
{
    return sinf(a);
}
 
template<>
inline ReturnTrait<double>::type Sin(const double& a) //Fonction 2
{
    return sin(a);
}

La fonction Sin, avec en paramètre, un float, un int ou un short.. renverra le résultat avec une précision simple (pas besoin de plus) et une double précision si c'est nécessaire.

[therwald]

C'est pas un peu violent pour ce qu'une simple surcharge ferait?

[Matthieu Brucher]

Si, je pense. J'aurais écrit ça :

Code :

1
2
template <class T> inline T Sin(T a) { return sinf(a); }
inline double Sin(double a) {return sin(a);}

puisque le compilateur va d'abord chercher dans les fonctions surchargées avant de regarder les templates.

[Awakening]

C'est pas un peu violent pour ce qu'une simple surcharge ferait?

Ben c'est ce que je pensais au début, mais le résultat n'est pas le même qu'une simple surcharge en fait.

@Matthieu Brucher : c'est ce que j'avais fait la toute première fois, mais le deuxième cas des tests suivant ne me plait pas :

Code :

1
2
3
4
5
6
7
8
template <class T> inline T Sin(T a) { return sinf(a); }
inline double Sin(double a) {return sin(a);}
 
//Tests
int a = Sin((int)1.000); // 0
float fa = Sin((int)1.000); // 0 => perte de la précison du à la conversion int => float. Un int en argument retourne malheureusement une valeur en int
float fb = Sin((float)1.000); // 0.841471
double da = Sin((double)1.000); // 0.841471

[therwald]

Pourquoi pas:

template<class T>
inline float sin(T a){return fsin(a);}
double sin(double a){return sin(a);}

?

[JolyLoic]

Tu veux faire quoi au juste ? Es-tu certain qu'il n'est pas mieux de faire le calcul en double, tout le temps, puis de convertir en float à la fin dans les cas où l'espace de stockage importe ?

As-tu lu : http://www.cs.berkeley.edu/~wkahan/JAVAhurt.pdf (en particulier la section qui commence page 30) ?