Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11

Rédéfinition de l'opérateur + dans toute une hierarchie de classes

13 réponses
Avatar
Marc
Bonjour,
j'ai une hierarchie de classes définie par exemple comme suit :

CBase
|
----------------------------------------------------
| | |
etc...
CType1 CType2 CType3
|
-----------------
| |
CType31 CType32

Je voudrais redéfinir l'opérateur + de telle sorte que je puisse additionner
tous les types à partir de pointeurs/références sur la classe de base.

CBase {
...
virtual CBase& operator+(const CBase&);
...
};

CType1 {
...
virtual CBase& operator+(const CBase&);
CBase& operator+(const CType2&);
CBase& operator+(const CType3&);
...
};
etc...
Le problème, c'est que lorsque je fais
CBase &type1=CType1();
CBase &type2=CType2();
type1+type2;
je détermine bien dynamiquement l'opérande gauche de l'opérateur (définition
virtuelle de celui-ci), mais pas l'opérande droite, qui doit me permettre
d'appeler l'implémentation appropriée de l'opérateur !
Je suis donc obligé de faire un switch intégral dans la fonction
virtual CBase& CType1::operator+(const CBase&)
pour déterminer le type de l'opérande droite et appeler la fonction
appropriée ! (évidement, ça permet quand même de détecter le type d'addition
demandé et de vérifier qu'elle est bien définie dans la classe si jamais on
ajoute d'autres classes à la hierarchie, ce qui est quand même plus
prudent..).
Ma question : y-a-il un moyen d'éviter ceci !? Je n'ai pas trouvé...
Merci

3 réponses

1 2
Avatar
Andre Heinen
On Mon, 19 Jan 2004 20:52:32 +0100, Fabien LE LEZ
wrote:

On Sun, 18 Jan 2004 11:30:49 +0100, "Marc" wrote:

CBase &type1=CType1();


C'est bizarre que ton compilo n'ait pas ralé : "CType1()" crée un
temporaire, et la référence "type1" ne pointe plus sur rien après
cette ligne.


Par contre, on peut écrire:

const CBase & type1 = CType1(); // avec const

Un objet temporaire est détruit à la fin de l'expression complète
dans laquelle il apparaît, sauf s'il est lié à une référence
const, auquel cas il sera détruit en même temps que sa référence:

void f() {
const CBase & type1 = CType1(); // création du temporaire
g(type1); // ok, le temporaire existe toujours
} // destruction de la référence et du temporaire

Il n'est cependant pas permis de lier un temporaire à une
référence non const. Voir Stroustrup 10.4.10.

virtual CBase& operator+(const CBase&);


Pas bon non plus : operator+ crée un nouvel objet, renvoyer une
référence est donc une erreur.


Ici, il y a effectivement un problème.

--
Andre Heinen
My address is "a dot heinen at europeanlink dot com"


Avatar
Andre Heinen
On Tue, 20 Jan 2004 19:06:25 +0100, Fabien LE LEZ
wrote:

On Tue, 20 Jan 2004 14:03:26 +0100, "Marc" wrote:

J'avoue que je trouve dommage que l'écriture
CBase &type1=CType1();
ne soit pas acceptée.


Dans quel(s) cas verrais-tu une utilité ?


string s1, s2;
...
string s3 = s1 + s2;
// création d'un temporaire, puis recopie dans s3
string & sr = s1 + s2;
// plus rapide: pas de recopie

--
Andre Heinen
My address is "a dot heinen at europeanlink dot com"


Avatar
Andre Heinen
On Fri, 23 Jan 2004 10:10:54 +0100, Andre Heinen
wrote:

string s1, s2;
...
string s3 = s1 + s2;
// création d'un temporaire, puis recopie dans s3
string & sr = s1 + s2;
// plus rapide: pas de recopie


Oups, il y a une faute: il fallait écrire
const string & sr = s1 + s2;
avec const.

--
Andre Heinen
My address is "a dot heinen at europeanlink dot com"

1 2