[operator] probleme seulement sous linux gcc 4.4.6

Version imprimable

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:

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:

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

05/01/2015, 14h38
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:

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:

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

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

Code:

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:

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

j'ai fait ca

Code:

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:

1
2
3
4
5

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

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:

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

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:

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 ?

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

Code:

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.

oui en fait je suis revenu et je vais faire comme tu m'as indiqué
pour le moment je fais la version Template des qu'elle est terminé je te montrerais
merci en attendant

voila ce que j'aimerais faire

Code:

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
//******************************************************************
// ALPHABASE & ALPHA
//******************************************************************
class AlphaBase {
public:
	virtual string toString() = 0;
	virtual double getValue() const = 0;
};
 
template<typename T>
class Alpha: public AlphaBase {
private:
	T value;
public:
	explicit Alpha(T value) :
			value(value) {
	}
	virtual string toString() {
		return "value = " + to_string((long long) value);
	}
	virtual double getValue() const {
		return (double) value;
	}
	// operators
	Alpha<T>& operator+=(const AlphaBase& rhs) {
		value += rhs.getValue();
		return *this;
	}
	Alpha<T>& operator+=(const double v) {
		value += v;
		return *this;
	}
	Alpha<T>& operator*=(const AlphaBase& rhs) {
		value *= rhs.getValue();
		return *this;
	}
	Alpha<T>& operator*=(const double v) {
		value *= v;
		return *this;
	}
};
 
template<typename T>
Alpha<T> operator+(const double v, const AlphaBase& rhs) {
	Alpha<T> ret = rhs;
	ret += v;
	return ret;
}
template<typename T>
Alpha<T> operator+(const AlphaBase& lhs, const double v) {
	Alpha<T> ret = lhs;
	ret += v;
	return ret;
}
template<typename T>
Alpha<T> operator+(const AlphaBase& lhs, const AlphaBase& rhs) {
	Alpha<T> ret = lhs;
	ret += rhs;
	return ret;
}
 
template<typename T>
Alpha<T> operator*(const double v, const AlphaBase& rhs) {
	Alpha<T> ret = rhs;
	ret *= v;
	return ret;
}
template<typename T>
Alpha<T> operator*(const AlphaBase& lhs, const float v) {
	Alpha<T> ret = lhs;
	ret *= v;
	return ret;
}
template<typename T>
Alpha<T> operator*(const AlphaBase& lhs, const AlphaBase& rhs) {
	Alpha<T> ret = lhs;
	ret *= rhs;
	return ret;
}

bon ca plante encore je sais pas si je peux utiliser AlphaBase dans les operateurs

FINALEMENT voila mon résultat qui fonctionne pas mal

Code:

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
//******************************************************************
// ALPHABASE & ALPHA
//******************************************************************
class AlphaBase {
public:
	virtual string toString() = 0;
	virtual double getValue() const = 0;
};
 
template<typename T>
class Alpha: public AlphaBase {
private:
	T value;
public:
	explicit Alpha(T value) :
			value(value) {
	}
	virtual string toString() {
		return "value = " + to_string((long long) value);
	}
	virtual double getValue() const {
		return (double) value;
	}
	// operators
	Alpha<T>& operator+=(const AlphaBase& rhs) {
		value += rhs.getValue();
		return *this;
	}
	Alpha<T>& operator+=(const double v) {
		value += v;
		return *this;
	}
	Alpha<T> operator+(const AlphaBase& rhs) {
		Alpha<T> ret = *this;
		ret += rhs;
		return ret;
	}
	Alpha<T> operator+(const double v) {
		Alpha<T> ret = *this;
		ret += v;
		return ret;
	}
 
	Alpha<T>& operator*=(const AlphaBase& rhs) {
		value *= rhs.getValue();
		return *this;
	}
	Alpha<T>& operator*=(const double v) {
		value *= v;
		return *this;
	}
	Alpha<T> operator*(const AlphaBase& rhs) {
		Alpha<T> ret = *this;
		ret *= rhs;
		return ret;
	}
	Alpha<T> operator*(const double v) {
		Alpha<T> ret = *this;
		ret *= v;
		return ret;
	}
};
 
template<typename T>
Alpha<T> operator+(const double v, const Alpha<T>& rhs) {
	Alpha<T> ret = rhs;
	ret += v;
	return ret;
}
template<typename T>
Alpha<T> operator*(const double v, const  Alpha<T>& rhs) {
	Alpha<T> ret = rhs;
	ret *= v;
	return ret;
}

la tu en pense quoi ?

05/01/2015, 17h51
Médinoc

Pourquoi toString() n'est-il pas lui aussi const?

Que je suis toujours pas d'accord.

Quel est l'intérêt de la classe de base ?

Dans les messages précédents, on n'utilise pas d'opérateurs particuliers pour faire alpha+x, pourquoi en faire un ? Tu as un constructeur, enlèves le explicit et repose toi sur lui.

Il y a une petite subtilité à cause du passage au template, il faut que l'opérateur soit trouvé dès qu'un alpha est présent mais en templatant les deux le compilateur ne pourra pas matcher un x avec un alpha (les constructeurs ne sont pas pris en compte lors de la mise en correspondance des templates). Une astuce consiste à passer en fonction libre amie :
Code:

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

06/01/2015, 05h54
ikeas

dans la réalité ma classe est beaucoup plus complexe que le Alpha elle contient pas seulement un T value mais aussi une date de validité et une validité (qui expose des paramètres plus important)

la classe de base m'est nécessaire pour des fonctions d'interface ou on ne sait pas vraiment qu'elle est le type de T

et en effet on peut passer le toString en const
06/01/2015, 07h28
Flob90

Héritage et opérateur arithmétiques ça ne va pas trop ensemble, tu pourrais détailler ton problème, j'ai l'impression que quelque chose ne va pas au niveau de la conception :
http://cpp.developpez.com/faq/cpp/?p...ique-de-valeur
http://cpp.developpez.com/faq/cpp/?p...tique-d-entite
06/01/2015, 07h35
ikeas

je ne veux pas mettre les opérateurs sur la classe parent
juste avoir la classe parente qui fourni des éléments de base et une abstraction des valeurs
mais plus globalement la solution que tu propose me va bien
je vais l’implémenter sur ma classe "officielle" lol

merci
13/01/2015, 11h12
koala01

Salut,

Tu sembles ne pas avoir compris un aspect absolument essentiel : les opérateurs mathématiques (entre autres, car il en va de même pour les opérateurs de comparaison) n'ont de sens que pour les classes qui ont sémantique de valeur, parce qu'il n'y a aucun sens à permettre l'utilisation d'un opérateur mathématique sur une personne ou sur une voiture, par exemple.

Or, le fait que tu disposes de fonction virtuelles démontre que tu envisage de faire intervenir ta classe dans une hiérarchie de classes, ce qui lui donne de facto une sémantique d'entité, au même titre qu'une classe Voiture ou qu'une classe Personne auront sémantique d'entité.

Du coup, tu as deux solutions :
Soit tu veilles à ce que ta classe ait sémantique de valeur, et, dans ce cas, tu n'as pas de fonctions virtuelles et tu dois t'interroger sur l'utilité d'avoir des opérateurs mathématique (parce que tous pas forcément de sens pour une classe donnée) et, s'ils ont du sens, l'opérateur d'addition et l'opérateur de multiplication seront des fonctions libres appelant l'opérateur += (respectivement *=) comme indiqué par Flob.

Soit, tu te dis que ta classe a, décidément, sémantique d'entité, et, dans ce cas, tu oublie purement et simplement l'idée de recourir aux opérateurs mathématique. Par contre, rien ne t'empêche de fournir des fonctions membres --dont le nom sera explicite quant au résultat escompté -- qui effectueront les calculs nécessaires sur certains membres de la classe ;)