moderna supporto della lingua + = ma non && =

Question

La maggior parte (ma solo in realtà conosco un piccolo numero, quindi non consente di ottenere schizzinosi su questo punto) linguaggi di alto livello supportano più operatori di assegnazione differenti.

a += 5; // increment a and assign result beack to a. 

Ma nessuno (che ho guardato (ancora una volta un piccolo numero)) sembrano supportare l'& & operatore =.
Il motivo che mi chiedo Recentemente ho visto questo:

// simplified. 
bool x = false; 


x = x && testA(); // perform test A/B/C/D stop on first failure. 
x = x && testB(); 
x = x && testC(); 
x = x && testD(); 

e mi chiedevo perché non abbiamo potuto utilizzare:

x &&= testA(); // perform test A/B/C/D stop on first failure. 
x &&= testB(); 
x &&= testC(); 
x &&= testD(); 

Il motivo è che & & = non è supportata in C/C++, che fatto pensiamo perché.

Esiste un logica (no pun intended) motivo per cui il linguaggio supporta tutti gli altri principali operatori, con un modulo di assegnazione, ma non il & & = o || =

Ho un vago ricordo di un argomento contro questi, ma le ricerche di Google e SO sono difficili quando il termine di ricerca è '& & =' e come risultato non ho trovato nulla.

Answer 1

e sono speciali nel senso che sono, nella maggior parte dei linguaggi, le uniche costruzioni che forniscono una valutazione di cortocircuito in modo che abbia senso per loro essere trattate in modo diverso dai normali operatori non in cortocircuito quando si tratta delle forme abbreviate. Il modo più semplice per evitare la confusione del cortocircuito &&= o no non lo include in primo luogo.

Answer 2

Quando mai avresti davvero bisogno di questo? In genere, quando esegui operazioni booleane, non stai aggiornando i valori, ma piuttosto calcolando qualcosa per un'operazione singola. Il tuo esempio non è molto realistico; non ci sono molti casi in cui lo faresti davvero.

Inoltre, in tutte le lingue che mi viene in mente l'assegnazione aumentata esiste solo per le operazioni bit a bit e aritmetiche, mai operazioni booleane.

Answer 3

Perl supporta questo. E 'molto utile per essere in grado di scrivere:

$x ||= $defaultX; 

Answer 4

La prima ragione è, che le lingue consentono di raggiungere il tuo obiettivo utilizzando il modulo "verbose". Dopodiché è disapprovato aggiungendo operatori per ogni caso insolito. Parte del motivo è che il progettista del linguaggio deve decidere saggiamente sulle precedenze degli operatori. Questo non è così facile come sembra - prendere C come un esempio che incasinato precedenze intuitive su &, |, && e ||.

La seconda ragione è che la maggior parte delle lingue moderne supportano una qualche forma di eccezioni. Il tuo caso può essere facilmente riscritto utilizzando eccezioni con il bonus aggiuntivo, che le informazioni sull'errore possono essere passate al chiamante più facilmente.

quindi la necessità per l'operatore speciale come questo è abbastanza piccola.

Oh, ho quasi perso la ragione più importante: C non li hanno. Ciò significa che è meglio descritto in A Brief, Incomplete, and Mostly Wrong History of Programming Languages:

1970 - Niklaus Wirth crea Pascal, un linguaggio procedurale. I critici denunceranno immediatamente Pascal perché utilizza la sintassi "x: = x + y" invece del più familiare tipo "x = x + y". Questa critica avviene nonostante il fatto che C non sia stato ancora inventato.

1972 - Dennis Ritchie inventa una potente arma che spara sia in avanti e all'indietro contemporaneamente. Non soddisfatto del numero di morti e di manomissioni permanenti di tale invenzione egli inventa C e Unix.

Questo mostra semplicemente che C è ancora un attrattore che non puoi sfuggire.

Answer 5

Diversamente da + = e amici, & & = non esegue il mapping su una singola istruzione hardware. È una specie di test-o-clear.