Discussion :

[Bktero]

Bonjour,

Voici un code :

Code :

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

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <iostream>
 
template<typename T>
class Wrapper {
public:
	Wrapper(T value) :
			raw_data(value) {
	}
 
	explicit operator T() const {
		return raw_data;
	}
 
	friend const Wrapper operator *(const Wrapper& multiplier, const Wrapper& multiplicand) {
		T raw_result = multiplier.raw_data * multiplicand.raw_data;
		return Wrapper(raw_result);
	}
 
private:
	T raw_data;
};
 
using MyWrapper = Wrapper<int>;
 
template<typename U>
int multiply_then_convert(U value) {
	U multiplied = 2 * value;
	int converted = multiplied; // WTF? explicit?
	return converted;
}
 
int main() {
	{
		// Avec fonction template
		MyWrapper value = 25;
		int converted = multiply_then_convert(value);
	}
 
	{
		// Equivalent
		MyWrapper value = 25;
		MyWrapper multiplied = 2 * value;
		int converted = multiplied;
	}
}

La ligne 43 ne compile pas. C'est normal, l'opérateur de conversion est explicite, il faut donc faire un cast.

La ligne 28 fait la même chose. L'instanciation de cette fonction template pour un tel U (= Wrapper<int>) ne devrait donc pas compiler. Or, la ligne 36 passe comme une lettre à la Poste. L'exécution produit le résultat attendu (50).

Pourquoi ?

Merci d'avance pour vos réponses !

[ternel]

Je confirme qu'avec mon gcc 7, j'ai le même résultat.

Et la même chose avec la variante suivante de ta template.

Code :

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

1
2
3
4
5
6
template<typename U>
int multiply_then_convert(Wrapper<U> value) {
	Wrapper<U> multiplied = 2 * value;
	int converted = multiplied; // WTF? explicit?
	return converted;
}

Je ne comprends pas pourquoi, cependant.

[koala01]

Salut,

La raison est toute simple: c'est toujours le premier paramètre qui prime pour les opérateurs...

Ainsi, quand tu écris un code proche de MyWrapper multiplied = 2 * value; //où value est de type MyWrapper, si tu laisses (temporairement) la partie gauche de l'affectation de coté, tu te retrouve avec 2*value; et, comme 2 est un littéral, le compilateur pourra choisir entre

• int operator * (int, int)
• unsigned int operator * (unsigned int , unsigned int)
• long operator * (long, long)
• unsigned long operator * (unsigned long, unsigned long)

(le tout dépendant du type qu'il va associer à 2 )

Mais il ne pensera jamais à tenter une conversion dans une optique SFINAE...

Alors, tu me demanderas sans doute pourquoi MyWrapper = value * 2; //où value est de type MyWrapper pourrait fonctionner

Hé bien, encore une fois, parce que le premier paramètre prime, et que, vu qu'il a un wrapper<int> comme premier paramètre, il va "logiquement" penser à faire la conversion de 2 en une instance (anonyme temporaire) de Wrapper<int>, vu qu'il saura que c'est... en cela qu'il doit faire la conversion

Si tu veux que le premier code fonctionne, tu devras fournir un opérateur * dont le premier paramètre puisse être un littéral, sous une forme qui pourrait très bien être proche de

Code :

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

1
2
3
4
template <typename T>
Wrapper<T> operator * (T litteral, Wrapper<T> const & w){
    return w * litteral; // on utilise l'opérateur qui fonctionne ;)
}

[jo_link_noir]

Bah moi j'ai une erreur avec gcc-7.2 et clang-5.

@koala: ce n'est pas la multiplication qui cause problème, mais le cast implicite vers un int. Ton résonnement est faux aussi, pour les fonctions libres, ce n'est pas le premier paramètre qui prime mais tous les paramètres dans leur ensemble. Mais puisque la conversion implicite vers un int est théoriquement impossible, le prototype operator*(int,int) est exclus et operator*(Wrapper<int>,Wrapper<int>) est utilisé (appel implicite du constructeur de Wrapper).

[koala01]

Ton résonnement est faux aussi, pour les fonctions libres, ce n'est pas le premier paramètre qui prime mais tous les paramètres dans leur ensemble.

Pour les fonctions libres, oui, mais, ici, on est dans le cas spécifique d'un opérateur, qui ne prend pas deux paramètres quelconques, mais bien deux opérandes : un qui se trouve à gauche de l'opérateur, et l'autre qui se trouve à droite de l'opérateur.

Or, dans ce cas particulier, c'est bel et bien l'opérande de gauche (et donc le premier paramètre) qui prime.La preuve, bien que les deux codes soient sensiblement identique, tu obtiendra un résultat différent avec

Code :

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

1
2
3
4
5
6
int main(){
    int i = 3;
    float f= 3.141592;
    auto result = i * f;
    std::cout<<result<<"\n";
}

ou avec

Code :

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

1
2
3
4
5
6
int main(){
    int i = 3;
    float f= 3.141592;
    auto result = f * i;
    std::cout<<result<<"\n";
}

Pourquoi parce que le compilateur effectue une conversion implicite du deuxième paramètre (de l'opérande de droite, pour être précis) pour qu'il corresponde au type du premier (de l'opérande de gauche, donc), et que le type du résultat dépend également de l'opérande de gauche

Ici, on est exactement dans le même cas: si tu veux pouvoir profiter de la commutativité entre un type primitif et ton type défini par l'utilisateur, tu dois prévoir les deux situations, car le compilateur n'envisagera jamais la conversion de l'opérande de gauche

EDIT : A la limite, tu prévoirais une fonction

Code :

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

1
2
3
4
template <typename T>
Wrapper<T> multiply(Wrapper<T> const & a, Wrapper<T> const & b){
    /* ... */
}

là, effectivement, tu devrais pouvoir utiliser deux wrapper, un wrapper et un entier (dans n'importe quel ordre), voir même -- a priori -- deux entiers, car le compilateur envisagera la conversion implicite si elle lui est autorisée (ce qui est le cas ici).

Mais, c'est valable pour les fonctions libres, pas pour les opérateurs

[jo_link_noir]

Pour les fonctions libres, oui, mais, ici, on est dans le cas spécifique d'un opérateur, qui ne prend pas deux paramètres quelconques, mais bien deux opérandes : un qui se trouve à gauche de l'opérateur, et l'autre qui se trouve à droite de l'opérateur.

Ce qui est identique à un appel de fonction libre, sauf au niveau de la syntaxe.

Or, dans ce cas particulier, c'est bel et bien l'opérande de gauche (et donc le premier paramètre) qui prime.La preuve, bien que les deux codes soient sensiblement identique, tu obtiendra un résultat différent avec [...]

Non, le résultat est identique. Sur les scalaires, les opérandes sont convertis vers le type pouvant prendre la plus grande valeur entre les 2 opérandes. Donc int+float ou float+int donne toujours un float car l'opérateur utilisé est operator+(float,float).

EDIT : A la limite, tu prévoirais une fonction

Code :

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

1
2
3
4
template <typename T>
Wrapper<T> multiply(Wrapper<T> const & a, Wrapper<T> const & b){
    /* ... */
}

là, effectivement, tu devrais pouvoir utiliser deux wrapper, un wrapper et un entier (dans n'importe quel ordre), voir même -- a priori -- deux entiers, car le compilateur envisagera la conversion implicite si elle lui est autorisée (ce qui est le cas ici).

Mais, c'est valable pour les fonctions libres, pas pour les opérateurs

Si. C'est ce qui d'ailleurs fait dans le code de @Bktero et cela fonctionne sans surprise. Sauf avec 2 entiers bien sûr.