Meta-programation, template et cast implicite

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.

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

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); }

---

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 ?

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); }

---

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.

Merci pour toutes ces réponses.

Citation:

---

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.

Citation:

---

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é.

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.

Citation:

---

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:

---

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

---

[...]

---

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

Citation:

---

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' :". :P
(D'ailleurs, j'ai fait le même abus de langage que Awakening ...)

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....

J'aime ce forum !

On en apprend toujours plus que prévu. :D

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.

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

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.

Citation:

---

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

---

Pourquoi pas:

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

?

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) ?