C # optimisant les opérateurs surchargés

Question

Renvoyer un nouvel objet sur des opérateurs surchargés semble être la seule chose à faire. Droit?

• Si vous avez une classe (X) contenant un grand tampon
• Une partie du tampon contient du contenu, le reste est libre.
• Vous avez surchargé l'opérateur binaire + pour fusionner deux objets (du même type) en créant un nouvel objet contenant le contenu ajouté des deux opérandes.

En d'autres termes:

z = x + y // z is a new object containing the appended data from x and y. 

C’est bien évidemment parce que nous ne voulons pas modifier x ou y pendant l’opération. Cependant, les spécifications du langage C # 7.2.2 disent:

Lorsqu'un opérateur binaire est surchargé, l'opérateur d'affectation correspondant (le cas échéant) est également implicitement surchargé.

cela signifie que:

x += y;  // will create a new x, copy contents of old x merged with y 
         //  and the old x will be garbage collected at some point

Cela est douloureux, car il pourrait être beaucoup plus rapide de simplement copier le contenu de y dans la partie libre de x. De cette façon, nous ne copions pas un objet volumineux et ne laissons pas de dégâts à la gentille personne chargée de la collecte des ordures.

Je réalise que cela pourrait être fait avec un simple x.Add (y). Je suis curieux de savoir s’il existe un moyen de le faire en utilisant des opérateurs. par exemple, pour comprendre que nous sommes dans l'opérateur d'affectation et effectuer la routine optimisée.

Answer 1

J'aime personnellement la façon dont C # a implémenté cela.

C’est plus "évident" " que:

x += y;

et

x = x + y;

Devrait avoir le même comportement. En C #, ceci est appliqué. Avec des surcharges séparées, les utilisateurs pourraient abuser de l'opérateur et l'empêcher d'agir de la même manière.

La différence de performances sera tellement minime, et cela facilite également la mise en œuvre et la maintenance. Je préfère donc fortement l’approche C #.

Answer 2

Tous les opérateurs binaires mathématiques renvoient un nouvel objet. Par exemple. Vous ne voudriez pas que 2 + 3 modifie la valeur de l'un d'entre eux en cinq simplement parce que vous les ajoutiez. En d'autres termes, la sémantique des opérateurs en question est très claire et appliquée à travers les spécifications. Si vous voulez quelque chose de différent, vous devrez faire quelque chose de différent :). Et j'aime bien comparer cela à c ++ où vous pouvez créer une surcharge telle que A = B = C pourrait entraîner la suppression de C, B étant non affecté et A égalant n'importe quelle valeur sans égard pour C ou B