Perché non posso sovraccaricare l’operatore + = in C #? Ma posso ancora usarlo?

Possibile duplicato:
Un modo semplice per sovraccaricare l’operatore di assegnazione composto in C #?

Stavo giocando con gli eventi e gli eventi pensati sono strani. Perché non potevo semplicemente implementarli in una class generica. Così ho provato e ho scoperto che I CANT OVERLOAD + =. Dalle specifiche della lingua trovate qui

The overloadable unary operators are: + - ! ~ ++ -- true false The overloadable binary operators are: + - * / % & | ^ <> == != > = <= 

+ = non è elencato. Ora, prima di dire che non c’è motivo di sovraccaricare + = vorrei far apparire il fatto che C # ha eventi che usano l’operatore + = e il fatto che ho tentato di implementare un evento per divertimento e ho voluto usare l’operatore + =. Ora, ho la sensazione che qualcuno dirà perché esistono gli eventi, perché è l’unica ragione. Comunque voglio mostrarti puoi usare + = con la struttura TimeSpan. Vai a provarlo, var ts= new TimeSpan(); ts += ts; var ts= new TimeSpan(); ts += ts; compilerà ed eseguirà.

Ho guardato la definizione di TimeSpan e non ho idea di come lo consenta. Ho visto un public static TimeSpan operator +(TimeSpan t); che sembrava sospetto ma poi me ne rendo conto per qualcosa come var name = +ts; come come puoi fare var name = -ts; per la negazione.

Quindi la mia domanda è, come uso il + = per la mia struct o la mia class. Sembra essere supportato non riesco a trovare la documentazione su di esso.

Gli eventi non sovraccaricano l’operatore += e -= . Questo è solo hardcoded nel compilatore C # che lo traduce nei metodi di aggiunta / rimozione di quell’evento.

Puoi solo sovraccaricare + e - che poi sovraccaricano indirettamente += e -= . Se sovraccarichi + automaticamente x += y diventa sovraccarico a x = x + y . Quindi per il tuo tipo non hai bisogno di aggiungere altro lavoro. Basta sovraccaricare + e otterrai += gratuitamente. Questo naturalmente richiede l’argomento sul lato sinistro e il tipo di risultato è compatibile, ma di solito è il caso.


La ragione per cui non è ansible sovraccaricare += separatamente è molto probabile che crei semantica strana per i tipi di riferimento. Se += modificato l’istanza esistente del lato sinistro, il seguente codice si comporterebbe in modo strano:

 MyClass x=new MyClass(); MyClass y=x; x+=SomeThing; y has changed now too 

D’altra parte con += significato x = x+y questo codice crea una nuova istanza che assegna a x. E l’istanza originale rimane non modificata in y;


In C ++, invece, è ansible specificare in modo sicuro un sovraccarico separato per += perché è ansible sovraccaricare l’assegnazione e il copy-constructor contemporaneamente e utilizzarlo per ottenere la semantica corretta.

L’operatore + = non può essere sovraccaricato direttamente, ma i tipi definiti dall’utente possono sovraccaricare l’operatore +.

Un’espressione che usa l’operatore + = assegnazione, come Copia

x + = y

è equivalente a Copia

x = x + y

msdn

+= è solo una scorciatoia per l’aggiunta, quindi l’assegnazione. Puoi sovraccaricare l’operatore + , il che rende anche l’operatore += :

Questo compila

 class P { public static P operator +(P rhs, P lhs) { return null; } } void Main() { P p = new P(); p += new P(); } 

(E, viceversa per - e -= operatori, ovviamente).

La documentazione non mente. Non è ansible sovraccaricare l’operatore += .

L’operatore += è solo una scorciatoia per usare l’operatore + . Un’operazione come x += y è tradotta in x = x + y dal compilatore.

Quindi, per cambiare ciò che fa l’operatore += , devi sovraccaricare l’operatore + .