O título é enganoso, portanto, leia a pergunta inteira :-) .
Por "operador de atribuição composta", tenho em mente uma construção como esta op=
, por exemplo +=
. O operador de atribuição pura ( =
) não pertence à minha pergunta.
Por "por que" não quero dizer uma opinião, mas um recurso (livro, artigo, etc.) quando alguns dos designers ou colegas de trabalho etc. expressam seu raciocínio (ou seja, a fonte da escolha do design).
Estou intrigado com a assimetria encontrada em C ++ e C # ( sim, eu sei que C # não é C ++ 2.0 ) - em C ++ você sobrecarregava o operador +=
e depois escrevia quase automaticamente o +
operador apropriado , dependendo do operador definido anteriormente. Em C #, é inverso - você sobrecarrega +
e +=
é sintetizado para você.
Se não me engano, a abordagem posterior mata uma chance de otimização em caso de real +=
, porque um novo objeto deve ser criado. Portanto, deve haver uma grande vantagem dessa abordagem, mas o MSDN é muito tímido para falar sobre isso.
E eu me pergunto qual é essa vantagem - por isso, se você descobriu uma explicação em algum livro em C #, vídeo de conversa sobre tecnologia, entrada de blog, ficarei grato pela referência.
A coisa mais próxima que encontrei é um comentário no blog de Eric Lippert. Por que os operadores sobrecarregados sempre estão estáticos em C #? de Tom Brown. Se a sobrecarga estática foi decidida primeiro, ela simplesmente determina quais operadores podem ser sobrecarregados para estruturas. Isso determina ainda o que pode ser sobrecarregado para as classes.
fonte
+=
primeiro parece absurdo; por que você sobrecarregaria uma operação combinada, e não suas partes?*=
mutação de um tipo de referência semanticamente incorreta.Respostas:
Não consigo encontrar a referência para isso, mas meu entendimento era que a equipe de C # queria fornecer um subconjunto sensato de sobrecarga de operadores. Naquela época, a sobrecarga do operador teve uma má reputação. As pessoas afirmavam que ele ofuscava o código e só podia ser usado para o mal. No momento em que o C # estava sendo projetado, o Java havia nos mostrado que nenhuma sobrecarga de operador era meio irritante.
Portanto, o C # queria equilibrar a sobrecarga do operador para que fosse mais difícil fazer mal, mas você também poderia fazer coisas legais. Mudar a semântica da atribuição era uma daquelas coisas que sempre eram consideradas más. Ao permitir que
+=
seus parentes fossem sobrecarregados, permitiria esse tipo de coisa. Por exemplo, se+=
a referência fosse modificada em vez de criar uma nova, ela não seguiria a semântica esperada, levando a erros.fonte