Le titre est trompeur, alors lisez toute la question :-) .
Par «opérateur d'affectation composé», j'ai en tête une construction comme celle-ci op=
, par exemple +=
. L'opérateur d'affectation pure ( =
) ne fait pas partie de ma question.
Par «pourquoi», je ne veux pas dire une opinion, mais une ressource (livre, article, etc.) lorsque certains des designers, ou leurs collègues, etc. expriment leur raisonnement (c'est-à-dire la source du choix de conception).
Je suis intrigué par l'asymétrie trouvée en C ++ et C # ( oui, je sais que C # n'est pas C ++ 2.0 ) - en C ++, vous surchargeriez l'opérateur +=
, puis écririez presque automatiquement l' +
opérateur approprié en vous appuyant sur l'opérateur précédemment défini. En C #, c'est l'inverse - vous surchargez +
et +=
est synthétisé pour vous.
Si je ne me trompe pas, l'approche ultérieure tue une chance d'optimisation en cas de réel +=
, car un nouvel objet doit être créé. Il doit donc y avoir un gros avantage d'une telle approche, mais MSDN est trop timide pour en parler.
Et je me demande quel est cet avantage - donc si vous avez repéré une explication dans un livre en C #, une vidéo tech-talk, une entrée de blog, je serai reconnaissant pour la référence.
La chose la plus proche que j'ai trouvée est un commentaire sur le blog d'Eric Lippert Pourquoi les opérateurs surchargés sont-ils toujours statiques en C #? par Tom Brown. Si la surcharge statique a été décidée en premier, elle dicte simplement quels opérateurs peuvent être surchargés pour les structures. Cela dicte davantage ce qui peut être surchargé pour les classes.
la source
+=
semble d'abord absurde; pourquoi voudriez-vous surcharger une opération combinée plutôt que ses parties?*=
mutation d'un type de référence est sémantiquement incorrecte.Réponses:
Je ne trouve pas la référence pour cela, mais je croyais que l'équipe C # voulait fournir un sous-ensemble sain de surcharge d'opérateur. À l'époque, la surcharge de l'opérateur avait un mauvais coup dur. Les gens ont affirmé qu'il masquait le code et ne pouvait être utilisé que pour le mal. Au moment de la conception de C #, Java nous avait montré qu'aucune surcharge d'opérateur n'était un peu ennuyeuse.
C # voulait donc équilibrer la surcharge des opérateurs afin qu'il soit plus difficile de faire le mal, mais vous pouviez aussi faire de belles choses. Changer la sémantique de l'affectation était l'une de ces choses qui étaient toujours considérées comme mauvaises. En permettant à
+=
ses proches d'être surchargés, cela permettrait ce genre de chose. Par exemple, si+=
la référence était modifiée plutôt que d'en créer une nouvelle, elle ne suivrait pas la sémantique attendue, ce qui entraînerait des bogues.la source