Perché non è possibile sovraccaricare l'operatore di assegnazione composto in C #?

11

Il titolo è fuorviante, quindi leggi l'intera domanda: -) .

Per "operatore di assegnazione composto" ho in mente un costrutto come questo op= , ad esempio += . L'operatore di assegnazione puro ( = ) non appartiene alla mia domanda.

Per "perché" non intendo un'opinione, ma una risorsa (libro, articolo, ecc.) quando alcuni dei progettisti, i loro colleghi, ecc. esprimono il loro ragionamento (cioè la fonte della scelta progettuale).

Sono perplesso dall'asimmetria trovata in C ++ e C # ( si, so che C # non è C ++ 2.0 ) - in C ++ sovraccaricherai l'operatore += e poi quasi automaticamente scriverò il% co_de appropriato % operatore che si basa su un operatore definito in precedenza. In C # è al contrario: sovraccarichi + e + è sintetizzato per te.

Se non sbaglio, l'approccio successivo uccide una possibilità di ottimizzazione in caso di% effettivo di+=, perché deve essere creato un nuovo oggetto. Quindi ci deve essere un grande vantaggio di tale approccio, ma MSDN è troppo timido per parlarne.

E mi chiedo quale sia questo vantaggio - quindi se hai trovato spiegazione in qualche libro in C #, video di tecnologia, post di blog, ti sarò grato per il riferimento.

La cosa più vicina che ho trovato è un commento sul blog di Eric Lippert Perché gli operatori sovraccaricati sono sempre statici in C #? di Tom Brown. Se il sovraccarico statico è stato deciso per primo, determina semplicemente quali operatori possono essere sovraccaricati per le strutture. Ciò detta ulteriormente cosa può essere sovraccaricato per le classi.

    
posta greenoldman 30.05.2015 - 18:07
fonte

1 risposta

12

Non riesco a trovare il riferimento per questo, ma la mia comprensione è stata che il team C # voleva fornire un sottoinsieme sensato di sovraccarico dell'operatore. A quel tempo, il sovraccarico dell'operatore aveva un brutto colpo. La gente ha affermato che il codice era offuscato e poteva essere usato solo per il male. Quando è stato progettato C #, Java ci ha mostrato che l'overloading dell'operatore no era piuttosto fastidioso.

Quindi C # voleva bilanciare il sovraccarico dell'operatore in modo che fosse più difficile fare il male, ma si potevano fare anche cose belle. Cambiare la semantica del compito era una di quelle cose che erano considerate sempre malvagie. Consentendo a += e ai suoi parenti di essere sovraccaricati, permetterebbe questo genere di cose. Ad esempio, se += ha mutato il riferimento anziché crearne uno nuovo, non seguirà la semantica prevista, causando bug.

    
risposta data 30.05.2015 - 20:00
fonte

Leggi altre domande sui tag