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.

[ikeas]

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 :

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

[ikeas]

FINALEMENT voila mon résultat qui fonctionne pas mal

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
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 ?

[Médinoc]

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

[Flob90]

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 :

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

[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

[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

[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

[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