Discussion :

[S_ami]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Dreambeliever]

Salut

ça devrait être de ce genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Alp]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

?

[Invité]

Salut,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Invité]

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

[Dreambeliever]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

[Alp]

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

[S_ami]

merci

[Arzar]

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.

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

sera valide en C++0x

[Dreambeliever]

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

[Goten]

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 .

[Dreambeliever]

Merci!

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

Apparemment y'a aussi les decltype:

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.

[JolyLoic]

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.