les fonction template

bonjour tout le monde
j'ai une fonction somme qui fait la somme des deux nombre quelconque voila la déclaration de la fonction :

Code:

---

1 2 3 4 5

template<class T1,class T2> T1 somme(T1 a,T2 b){ return a+b; }

---

le problème c'est que le type de retour dépend toujours du nombre a
lorsque j'ai fait :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

#include <iostream> using namespace std; template<class T1,class T2,class T> T somme(T1 a,T2 b){ return a+b; } int main() { double a=somme(12,12.6); return 0; }

---

une erreur :
D:\c++SMI6\exercice2\main.cpp|15|error: no matching function for call to `somme(int, double)'|
merci de m'aider

Salut

ça devrait être de ce genre:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

#include <iostream> using namespace std; template<class T,class T1,class T2> T somme(T1 a,T2 b){ return a+b; } int main() { double a=somme<double>(12,12.6); return 0; }

---

Le problème c'est qu'en général, '+' est associé à un groupe (ou au moins monoïde) au sens Mathématique. Et l'une des caractéristiques principales, c'est que quand tu additionnes deux éléments :
- les deux appartiennent au même ensemble
- le résultat appartient au même ensemble
(on parle de stabilité de '+')

Donc, ne serait-il pas mieux ici d'avoir un signature de ce genre (auquel cas tu n'auras plus besoin de préciser le type de retour à la main car le compilateur ne peut pas le déduire) :

Code:

---

1 2	template <typename T> T add(T t1, T t2);

---

?

Salut,

A mon avis, le problème vient du fait que dans

Code:

---

1 2 3 4 5

template<class T1,class T2,class T> T somme(T1 a,T2 b){ return a+b; }

---

Ton compilateur n'a aucune idée du type T qu'il doit renvoyer quand tu lui passes un int et un double : somme(12,12.6); : 12 est un int, 12.6 un double, mais le retour, oui c'est un T, mais quoi? C'est pour cela qu'il chouine.

Je pense que tu devrais choisir T=T1, comme ca tu respectes l'associativité naturelle de l'addition. Le problème, c'est qu'alors somme(12, 12.6)=24. Sinon, tu peux forcer T comme double... oui mais somme(12,12)=24.0 (double)

Francois

Citation:

---

Envoyé par Alp

Et l'une des caractéristiques principales, c'est que quand tu additionnes deux éléments :
- les deux appartiennent au même ensemble
- le résultat appartient au même ensemble
(on parle de stabilité de '+')

---

Ne peut on pas additionner deux types différents en C++ (le compilateur caste comme il faut, non?). Et +, en informatique, c'est pour un groupe, pas un monoide, puisque les flottants sont signés, et tout élément d'un type entier a un inverse.

Enfin, quand je dis un groupe (ou un monoide), c'est pour les types entiers, seulement: l'addition en virgule flottante n'est pas associative.

Francois

Citation:

---

Envoyé par Alp

Donc, ne serait-il pas mieux ici d'avoir un signature de ce genre (auquel cas tu n'auras plus besoin de préciser le type de retour à la main car le compilateur ne peut pas le déduire) :

Code:

---

1 2	template <typename T> T add(T t1, T t2);

---

?

---

Salut,

Ton code est plus simple que le mien mais dans le cas où les types de t1 et t2 sont différents, il y aura toujours besoin de préciser T (mais, c'est vrai, dans le cas d'égalité y'a pas besoin)

Je remettais simplement en question l'utilité de fournir la possibilité d'avoir T1 et T2 différents, avec un troisième type T pour le retour.
Ca dépend des types que va donner le PO à sa fonction.

M'enfin qu'il s'agisse de vecteurs, de matrices, de nombres, on veut souvent T1 = T2 = T.

Après, ça peut être une exception ici ;)

merci :ccool:

Le problème initial est impossible à résoudre en C++98, en tout cas c'est ce que semble expliquer la proposition pour ajouter l'opérateur decltype pour le C++0x.

Citation:

---

The return type of a generic function often depends on the types of the arguments. In some cases the dependency can
be expressed within the current language. For example:

Code:

---

1 2	template<class T> T min(const T& a, const T& b) { return a < b ? a : b; }

---

In other cases this is not as easy, or even possible. Consider the following example:

Code:

---

1 2	template<class A, class B> R add(const A& a, const B& b) { return a + b; }}

---

The return type, denoted here with R, should be the type of the expression a + b. That type may, however, be A, B,
or something entirely different. In short, the type R depends on the types A and B in a way that is not expressible in
today’s C++.

---

Grâce à decltype, dans un monde idéal, on pourrait alors écrire ceci :

Code:

---

1 2 3 4 5

template<class A, class B> decltype(a+b) add(const A& a, const B& b) { return a + b; }

---

Malheureusement, ce n'est pas possible, car, si j'ai bien compris, les parseurs de C++ lisent le code de gauche à droite donc les variables "a" et "b" ne sont pas encore déclarées au moment où le parseur lit "decltype(a+b)"...

Il a donc fallu trouver une autre syntaxe...
Vous êtes bien assis ?

Code:

---

1 2 3 4 5

template<class A, class B> auto add(const A& a, const B& b) -> std::decltype(a+b) { return a + b; }

---

Et oui, en C++0X le type de retour d'une fonction pourra être à droite ! Et ce sera vrai partout.
Cette définition de fonction :

Code:

---

1 2 3 4

auto estPair(int i) -> bool { return i%2; }

---

sera valide en C++0x :fou:

A quand le C++0X sur windows? ^^

La bêta de VS2010 implémente déjà pas mal de features. Notamment les lambda expressions qui elle aussi voit leur type de retour indiqué à droite :).

Merci!

http://herbsutter.wordpress.com/2009...now-available/

Apparemment y'a aussi les decltype:

Citation:

---

C++0x features, check out the lambda functions (my fave), move-semantic rvalue references, the new auto, its good friend decltype, and the ever-helpful static_assert.

---

Une "solution" applicable aujourd'hui consiste à passer par une classe de traits, où l'on spécifie explicitement le type de retour que l'on veut en fonction de toutes les combinaisons de type des arguments que l'on s'attend à trouver.