Discussion :

[ikeas]

Bonjour

j'aimerais trouver une solution au problème suivant
en effet je peux pas changer de compilateur et j'ai fait des test avec visual studio (avec le même code) et ça passe

bref j'ai une classe :

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
 
class Zota {
	float value;
public:
	float getValue() {
		return this->value;
	}
	explicit Zota(float value) :
			value(value) {
	}
	virtual Zota operator+(Zota &ob) {
		return Zota(this->getValue() + ob.getValue());
	}
	virtual Zota operator+(double ob) {
		return Zota(this->getValue() + ob);
	}
	virtual Zota operator*(Zota &ob) {
		return Zota(this->getValue() * ob.getValue());
	}
 
	virtual string toString() {
		return to_string((long long)this->value);
	}
};

et j'execute le code suivant

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
 
cout << endl << "* test beta (ref)" << endl;
		Zota a(2);
		Zota b(3);
		Zota c(5);
		{
			Zota d = a + b + c;
			cout << " a + b + c = " << d.toString() << endl;
		}
		{
			Zota d = a + 10;
			cout << " a + 10 = " << d.toString() << endl;
		}
//		{
//			Zota d = 11 + a;
//			cout << " 11 + a = " << d.toString() << endl;
//		}
		{
			Zota d = a * b;
			cout << " a * b = " << d.toString() << endl;
		}
		{
			Zota d = (a * b) + c;   // CA PASSE
			cout << " (a * b) + c = " << d.toString() << endl;
		}
		{
			Zota d = c + (a * b); // CA COMPILE PAS
			cout << " c + (a * b) = " << d.toString() << endl;
		}

bref (a * b) + c ca passe et
c + (a *b) ca compile pas avec l'erreur suivante :
error: no match for ‘operator+’ in ‘c + Zota::operator*(((Zota&)(& b)))’

si vous avez une idée de la solution possible

merci

[Flob90]

Ca ne compile pas car tu retournes un temporaire et que ton opérateur d'adition utilise une simple référence, or un temporaire ne peut être attaché à une simple référence.

Une remarque plus générale, sauf dans certaines situation, la forme canonique des opérateurs binaires symétriques, c'est une fonction libre avec prise par référence constante :

Code :

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

1
2
3
4
5
6
 
Zota operator+(const Zota& lhs, const Zota& rhs) {
  Zota ret=lhs;
  ret+=rhs;
  return ret;
}

Et en fonction membre tu codes :

Code :

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

1
2
3
4
5
6
7
 
struct Zota {
  Zota& operator+=(const Zota& rhs) {
    //stuff
    return *this;
  }
};

[ikeas]

ok en effet ca règle le problème de compilation toutefois je vois pas ce qu'il faut mettre
dans

Code :

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

1
2
3
4
5
6
7
8
9
 
	Zota& operator+=(const Zota& rhs) {		
		//stuff
		return *this;
	}
	Zota& operator*=(const Zota& rhs) {
		//stuff
		return *this;
	}

si je suis ton principe en faisant

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
Zota operator+(const Zota& lhs, const Zota& rhs) {
	Zota ret = lhs;
	ret += rhs;
	return ret;
}
Zota operator*(const Zota& lhs, const Zota& rhs) {
	Zota ret = lhs;
	ret *= rhs;
	return ret;
}

[ikeas]

j'ai fait ca

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
Zota& operator+=(const Zota& rhs) {
		float x = rhs.getValue();
		this->value = this->value + x;
		//stuff
		return *this;
	}
	Zota& operator*=(const Zota& rhs) {
		float x = rhs.getValue();
		this->value = this->value  * x;
		//stuff
		return *this;
	}

en corrigeant

Code :

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

1
2
3
4
5

float getValue() const {
		return this->value;
	}

[Flob90]

Ce qui correspond à ton opération, a+=b pour les types fondamentaux, c'est comme faire a=a+b, dans ton cas ça donne :

Code :

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

1
2
3
4
5
6
7
8
9
 
Zota& operator+=(const Zota& rhs) {		
	value+=rhs.value; //inutile d'utilise this et getValue
	return *this;
}
Zota& operator*=(const Zota& rhs) {
	value*=rhs.value; //inutile d'utilise this et getValue
	return *this;
}

[ikeas]

merci je suis passé par une autre écriture pour régler les problèmes des formules
type :

• 11 + gamma
• gamma + 11
• etc etc ....

voici ce que ca donne (j'ai changé le nom de la classe)

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
 
class Gamma {
	float value;
public:
	float getValue() const {
		return value;
	}
	virtual string toString() {
		return to_string((long long)value);
	}
	Gamma(float value) :
			value(value) {
	}
	Gamma& operator+(const Gamma& rhs) {
		value += rhs.value;
		//cout << " - operateur+ = " << value << endl;
		return *this;
	}
	Gamma& operator+(const double ob) {
		value += ob;
		//cout << " - operateur+(double) = " << value << endl;
		return *this;
	}
	Gamma& operator*(const Gamma& rhs) {
		value *= rhs.value;
		//cout << " - operateur* = " << value << endl;
		return *this;
	}
};
Gamma operator+(const double ob, const Gamma& rhs) {
	Gamma ret = rhs;
	ret = ret + ob;
	return ret;
}

tu en pense quoi ?

[Flob90]

Que tu n'as pas suivi ce que j'ai marqué avant, donc je ne risque pas d'être d'accord

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
 
#include<iostream>
 
struct Gamma {
	Gamma(const float& value) : value(value) {}
 
	Gamma& operator+=(const Gamma& rhs) {
		value += rhs.value;
		return *this;
	}
	Gamma& operator*=(const Gamma& rhs) {
		value *= rhs.value;
		return *this;
	}
 
	friend std::ostream& operator<<(std::ostream& os, const Gamma& gamma) {
		os << gamma.value;
		return os;
	}
	friend std::istream& operator>>(std::istream& is, Gamma& gamma) {
		is >> gamma.value;
		return is;
	}
 
private:
	float value;
};
 
Gamma operator+(const Gamma& lhs, const Gamma& rhs) {
	Gamma ret=rhs;
	ret+=rhs;
	return ret;
}
Gamma operator*(const Gamma& lhs, const Gamma& rhs) {
	Gamma ret=rhs;
	ret*=rhs;
	return ret;
}
 
int main()
{
	Gamma gamma=1;
	std::cout << gamma+1 << 1*gamma << std::endl;
}

Je ne sais pas à quoi va servir ta classe par contre.