Surcharge d'opérateur sur des structures

Marsh Posté le 15-07-2007 à 20:41:47

Salut,

est-il possible de surcharger un opérateur non pas dans une classe, mais dans une struct ?

J'ai une structure du type :

Code :

struct Structure
{
ClasseA variable1;
};
Structure struct1;
Structure struct2;

Si je fais :

Code :

struct2 = struct1;

J'ai une erreur :

Code :

Ambiguity between ClasseA::operator =(ClasseA) and ClasseA::operator=(const ClasseA & )

Cependant, je n'ai pas ce problème lorsque j'appelle explicitement :

Code :

ClasseA objet1;
ClasseA objet2;
objet1 = objet2;

;

Le problème semble définitivement lié à l'encapsulation dans une struct.

J'espère que vous pourrez m'aider :jap:

Reply

Marsh Posté le 15-07-2007 à 20:41:47

Reply

Marsh Posté le 15-07-2007 à 20:53:40

comment il est défini ton operator = de ClasseA ?

Reply

Marsh Posté le 15-07-2007 à 20:59:50

Code :

template <class type> void
Coord_2D<type>::operator =(type value)
{
x=value;
y=value;
}

Message édité par Vel-Ryphon le 15-07-2007 à 21:00:02

Reply

Marsh Posté le 15-07-2007 à 22:28:02

Code :

Coord_2D<type> & Coord_2D<type>::operator = ( const type &value )
{
if( this != &value )
{
x=value;
y=value;
}
return *this;
}

const type &value, sinon ça fait théoriquement une copie (par constructeur de recopie)

pas void et return *this, parce que sinon tu peux pas écrire a=b=c;

sur des types complexes, tester si this != &value pour éviter de détuire l'object par auto-digestion sans apéro. (pour du float/int ça devrait passer) là je te l'ai mis pour le principe

edit: pardon, j'avais pas vu que tu voulais initialiser les deux coordonnées et non définir l'opérateur d'assignement objet à objet

si tu définis un operator = ( quelquonque ), il faut ptet obligatoirement définir un opérateur d'assignement.
mais quand même Coord_2D<type> & Coord_2D<type>:: operator = ( const type &value )
(ou const type value )

---

pour lever l'ambiguité, ptet ne pas faire d'opérateur = ( const type value ), mais un constructeur explicite ( const type value ), et laisser le compilo optimiser l'assignement/construction dans le cas des " variable1=2 ";
ça évitera les collisions avec l'assignement.

Message édité par bjone le 15-07-2007 à 22:39:35

Reply

Marsh Posté le 15-07-2007 à 23:02:12

Merci beaucoup !!

edit : j'ai suivi tes premières recommandations, ça m'a fait prendre conscience de la maladresse de mes opérateurs génériques. après avoir tout rectifié, tout se compile niquel, et j'imagine que ça optimise pas mal (il n'y a plus de copies etc)

Message édité par Vel-Ryphon le 15-07-2007 à 23:09:17

Reply

Marsh Posté le 16-07-2007 à 07:39:28

Arg j'ai un nouveau problème :fou:

Voici mon opérateur :

Code :

template <class type> Coord_3D<type>&
Coord_3D<type>::operator +(const Coord_3D<type>& value)
{
Coord_3D<type>& result (x+value.x, y+value.y, z+value.z);
return result;
}

Et voici mon appel :

Code :

Coord_3D<float>&
cubic_interpolation_with_tangent(const Coord_3D<float>& start_value, const Coord_3D<float>& start_derivative, const Coord_3D<float>& end_value, const Coord_3D<float>& end_derivative, const float& interpolation_coefficient, const Coord_3D<float>& tangent)
{
...
Coord_3D<float> a =start_value;
Coord_3D<float> b =start_value + start_derivative;
...

J'obtiens l'erreur suivante :

Code :

'operator+' not implemented in type 'Coord_3D<float> for arguments of the same type in function cubic_interpolation_with_tangent'

Si je fais :

Code :

Coord_3D<float> a =start_value;
Coord_3D<float> b =a + start_derivative;

Y'a pas de souci. CA vient donc du fait que ce soit une référence, je suppose. Mais comment améliorer ma surcharge d'opérateur pour que la première écriture compile ?

Reply

Marsh Posté le 16-07-2007 à 10:12:42

oulà le

Coord_3D<type> &result (x+value.x, y+value.y, z+value.z);

est pas bien joli joli

si c'est une variable temporaire, y'a pas à avoir de &
le & en passage évite les recopies, et en retour c'est que tu te retounes toi-même car tu existeras toujours même après le retour (return *this).

ensuite, il vaut mieux faire l'opérateur +=, car de l'opérateur += peut découler l'opérateur +.

Message cité 1 fois

Reply

Marsh Posté le 16-07-2007 à 10:14:38

bon le mieux, c'est comme d'hab tu regardes boost:

http://www.boost.org/libs/utility/operators.htm

ils t'indiquent quels operateurs surcharger, et ils s'occupent du reste

Reply

Marsh Posté le 16-07-2007 à 19:35:28

bjone a écrit :

oulà le

Coord_3D<type> &result (x+value.x, y+value.y, z+value.z);

est pas bien joli joli

si c'est une variable temporaire, y'a pas à avoir de &
le & en passage évite les recopies, et en retour c'est que tu te retounes toi-même car tu existeras toujours même après le retour (return *this).

ensuite, il vaut mieux faire l'opérateur +=, car de l'opérateur += peut découler l'opérateur +.

mais vu qu'il s'agit de l'opérateur +, je ne veux pas que l'opérateur modifie les variables de la classe appelante, donc le return this n'a pas lieu d'être.

J'ai encore un peu de mal avec le concept de référence.

Dans mon exemple, si je fais :

Code :

1.
template <class type> Coord_3D<type>&
2.
Coord_3D<type>::operator +(const Coord_3D<type>& value)
3.
{
4.
Coord_3D<type> result (x+value.x, y+value.y, z+value.z);
5.
6.
return result;
7.
}

Donc, si j'enlève le &, est-ce que cela va changer quelque chose sur le plan mémoire ? je souhaite éviter le maximum de copie etc, je veux juste qu'il renvoie la variable qu'il vient d'instancer, sans la dupliquer dans une autre.

Reply

Marsh Posté le 16-07-2007 à 23:49:21

déjà c'est pas légal/logique, puisque ce serait une référence sur un objet temporaire. le & ou * implique un objet persistant au retour de la fonction.

regarde la page de boost.

tu implémente les += -=, etc et tu hérites de boost::operators<>

Reply

Surcharge d'opérateur sur des structures

Sujets relatifs:

Leave a Replay