surcharge operateur &

Bonjour à tous

Dans un tp de prog en c++ on me demande de surcharger l'opérateur & pour qu'il affiche et renvoie l'adresse de l'objet.
J'arrive à le faire mais je n'en vois pas l'intéret.
Ma question est donc comme vous pouvez le deviner est :

Quel est interet de surcharger l'opérateur & ?

Merci d'avance de vos réponses

Citation:

---

Envoyé par kekelg2006

Bonjour à tous

Dans un tp de prog en c++ on me demande de surcharger l'opérateur & pour qu'il affiche et renvoie l'adresse de l'objet.
J'arrive à le faire

---

8O
Et tu fais comment exactement ?

Edit : Ok j'ai pigé. Effectivement je n'en vois pas d'intérêt immédiat non plus à part peut être démontrer que le C++ permet de faire des trucs vraiment dingue des fois et qu'il faut donc apprendre à se méfier de tout, même d'un innocent & :mrgreen:

En même temps, c'est pas le but de l'opérateur &? (ok il affiche pas, mais il renvoie l'adresse).

Salut,

Citation:

---

Envoyé par Goten

En même temps, c'est pas le but de l'opérateur &? (ok il affiche pas, mais il renvoie l'adresse).

---

Sauf erreur, lorsque surchargé, l'opérateur & a normalement pour but... d'effectuer un AND binaire...

En effet, l'opérateur & servant comme "opérateur permettant d'obtenir l'adresse de" n'est pas surchargeable, par contre, l'opérateur de comparaison binaire bien:aie:

L'idée générale étant, par exemple, de le définir pour une énumération proche de

Code:

---

1 2 3 4 5 6 7 8

enum eMyEnum { meValue1 = 1<<0, meValue2 = 1<<1, meValue3 = 1<<2 /*,   ...   */ };

---

sous la forme de

Code:

---

1 2 3 4 5

eMyEnum operator & (eMyEnum e1, eMyEnum e2) { return eMyEnum(static_cast<int> e1 & static_cast<int> e2); }

---

Autrement dit, tu peux proprement enguirlander ton prof pour te demander de faire quelque chose de tout à fait erroné :D

[EDIT]PS: Ce sont les opérateur * (ce qui est pointé par) et -> ((l'élément du pointeur) qui peuvent être surchargés, lorsque ta classe a sémantique de pointeur ( comme c'est le cas pour les itérateurs ;))

Ben si Koala, justement, l'opérateur & ("address-of operator") EST surchargeable, c'est ce que j'ai découvert avec stupeur en essayant. :mrgreen:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

#include <iostream>   struct S { S* operator& () { std::cout << this << std::endl; return (S*)0x666; } int i; };   int main() { S s; S* sptr = &s; sptr->i = 5; // OUCH }

---

Désolé koala, mais l'opérateur adresseof est surchargeable :).

Et donc je me répète : au final ta surcharge à le comportement par défaut de l'opérateur... je capte pas. (a moins que ça soit juste pour l'affichage que le prof voulait surcharger?)

Citation:

---

Envoyé par La norme

13.5.2
Both the unary and binary forms of
+ - * &
can be overloaded.

---

Je pense que mon prof voulais juste qu'on manipule la surchage des opérateurs dont & (en y ajoutant un affichage).

Apres ma question etait quel peut etre l'interet de la surcharge d'un tel opérateur dans "la vrai vie" :D .

Mais apperement il n'y a pas beaucoup de cas figure ou sa se présente.

Merci à tous de votre réponse si vous avez d'autres exemples je suis preneur.

boost serialize fait cela non?
http://www.boost.org/doc/libs/1_40_0...doc/index.html

C'est plutôt la version binaire qui est surchargé non?

Voici la question du tp sera plus clair.

"Ecrire une surcharge de l’opérateur & qui affiche l’adresse en question, et renvoie l’adresse
de l’objet. Tester cette méthode."

L'objet en question est un nuage de points constitue de plusieurs points

J'ai pas eu de probleme pour y répondre mais comme je l'ai déja dit. Je ne vois juste pas l'interet de surchager ce type d'opérateur

en fait, il y a un intérêt à surcharger les opérateurs "qui vont bien" avec certaines classes, mais pas n'importe lesquels.

Ainsi, tu souhaiteras souvent surcharger

• les opérateurs de flux << et / ou >> pour des classes ayant vocation à assurer la persistance de données (ou à en assurer le transport dans un flux quelconque),
• les opérateurs artihmétiques ( +, -, *, / ) sur des classes vecteur ou matrice au sens mathématique du terme,
• les opérateurs étoile, fleche, d'incrémentation et de décrémentation pour les classes ayant sémantique de pointeur,
• les opérateurs logiques (AND, OR, XOR) sur les classes ayant sémantique d'état
• les opérateurs de comparaison ( <, >, == et similaires) pour les classes ayant sémantique de valeur (ou, du moins étant "comparables")
• les opérateur new / new[] et delete / delete[] dans certains cas
• ...

parce que ces opérateurs sont utiles à l'utilisation de la classe en fonction de sa sémantique.

Mais s'il y a bien un opérateur pour lequel la surcharge n'a, à mon avis, aucun sens, c'est l'opérateur & dans son acception "address of"

Citation:

---

Envoyé par kekelg2006

Apres ma question etait quel peut etre l'interet de la surcharge d'un tel opérateur dans "la vrai vie" :D .

Mais apperement il n'y a pas beaucoup de cas figure ou sa se présente.

Merci à tous de votre réponse si vous avez d'autres exemples je suis preneur.

---

+ 1
Je serais moi aussi curieux de connaitre un exemple valable d'utilisation de cet opérateur.

J'ai parfois l'impression que la personne (Stroustrup ?) qui a rédigé la liste des opérateurs surchargeables lors de la création/normalisation du C++ à simplement fait un recensement exhaustif de tous les opérateurs possibles sans se questionner sur leur pertinence. Et mine de rien, le futur lui a donné raison pour des opérateurs a priori un peu foufou comme -> et *, qui se sont révélés indispensables pour implémenter les pointeurs intelligents....

Bon par contre pour l'opérateur & je cherche encore. :mrgreen:

Ca viendra peut-être, après tout, les boosteurs ont bien réussi à trouver un emploi pertinent à l'opérateur "virgule" (!) dans Boost.Assign !

Ok merci.

Apres avoir poser la question a mon prof.

Il ma dit que cela pouvait etre utile (de redéfinir l'opérateur &) pour retourner l'adresse d'un membre encapsulé. Par exeme exemble lorsque on veut retourner l'adresse d'une structure encapsulé dans une classe.

Mais effectivement dans le cas du TP cela n'a pas grand intéret.

Merci a tous.

Citation:

---

Envoyé par kekelg2006

Ok merci.

Apres avoir poser la question a mon prof.

Il ma dit que cela pouvait etre utile (de redéfinir l'opérateur &) pour retourner l'adresse d'un membre encapsulé. Par exeme exemble lorsque on veut retourner l'adresse d'une structure encapsulé dans une classe.

Mais effectivement dans le cas du TP cela n'a pas grand intéret.

Merci a tous.

---

dans l'autre sens, je serais d'accord, mais, dans le sens qu'il présente, j'ai de sérieux doutes...

En effet, si ta classe a sémantique de pointeurs (comme c'est le cas, je le répète, pour les itérateurs), il semble "cohérent" de surcharger les opérateurs * et -> de manière à ce qu'il permettent d'accéder à l'élément pointé.

Par contre, dans l'autre sens ...:aie: :aie: :aie:

Citation:

---

Envoyé par kekelg2006

Ok merci.

Apres avoir poser la question a mon prof.

Il ma dit que cela pouvait etre utile (de redéfinir l'opérateur &) pour retourner l'adresse d'un membre encapsulé. Par exeme exemble lorsque on veut retourner l'adresse d'une structure encapsulé dans une classe.

Mais effectivement dans le cas du TP cela n'a pas grand intéret.

Merci a tous.

---

Oula, moi je veux bien, mais ça peut faire de sacré surprise à celui qui va utiliser le code là!


(à arzar, encore plus fort y'a l'op+ unaire qui est utilisé dans boost... )

Voila l'exemple qu'il me donne :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

struct Encapsulante { inti ; // Donnée à accéder } ; Encapsulee o ; struct Encapsulee { Encapsulee ∗ operator−>(void ) const { return &o ; } Encapsulee ∗ operator& (void ) const { return &o ; } Encapsulee & operator* (void ) const { return o ; } };

---

je dirai que ca peut etre pas mal pour interdir a quelqu'un d'utiliser un pointeur sur l'objet (donc on ne peut y accéder que par valeur et par référence), en retournant "void" (si c'est possible de changer le type de retour). la comme ca j'ai pas d'exemple ou ca serait utile, mais on ne sait jamais.

Je sais que certains pointeurs COM intelligents surchargent l'opérateur & unaire, pour qu'on puisse les passer en paramètre à une fonction qui "retourne" un pointeur d'objet.
Si je me souviens bien, l'opérateur surchargé vérifie que le pointeur interne est nul avant d'accepter.