Utilizzi pratici del fatto che l'operatore di incremento del prefisso C++ restituisce un lvalue

Question

Ho appena saputo che il risultato dell'operatore di incremento del prefisso in C++ è un lvalue. Ci sono probabilmente casi in cui questo comportamento aiuta il programmatore ad essere più efficace, ma non potrei pensare a nessuno. Quali sono alcuni usi idiomatici di questo comportamento dell'operatore di incremento del prefisso?

Answer 1

i=9; 
j=10; 
k = ((i)>(j))?(j):(++i); 

Nel caso di cui sopra hanno un uso dell'operatore prefisso incremento come si può c abbiamo prima controllare i> j che sarà falso in questo caso allora stiamo assegnando il valore ++ i ak che darà noi k = 1. Qui in una singola istruzione abbiamo usato due volte ma una volta il valore era 9 e un'altra volta il valore era 10. Se si tenta di ottenere ciò senza l'operatore di prefisso incremento dovremmo usare un'altra variabile temporanea per memorizzare il valore di quindi incremento i per assegnare a k. Senza usare operatore prefisso

i=9; 
j=10; 
Temp=i; 
i=i+1; 
k = ((Temp)>(j))?(j):(i); 

Ancora se si arriva ad una conditin dove temp è greter di j allora avremo il valore dei incrementata anche se noi non usarlo. Usando l'operatore di prefisso il valore di i aumenterà solo se ho meno di j.

Answer 2

La modifica da C, dove ++ x è un rvalue a C++, dove ++ x per i tipi built-in è un lvalue è probabilmente perché ci sono molte più applicazioni utili. Ad esempio, è possibile definire una funzione alternativa come

void f (int x); 
void f (int& x); 

e il fatto che ++ x è un Ivalue consente di chiamare f (x ++); in ogni caso. In C, solo il primo caso era legale e funziona perfettamente con un valore. In C++, vuoi un lvalue.

Answer 3

Il prefisso motivo ++ restituisce un lvalue è ortogonalità; Non ho visto alcun uso per esso che non si qualificherebbe come offuscamento. Ma la domanda è: quali regole si applicano per fare in modo che un'espressione sia un lvalue. In C, la regola di base è che le espressioni che modificano uno dei loro operandi non sono lvalue, ma un certo numero di persone che hanno voluto sostenere cose come:

T& 
someFunction(T& lhs, T const& rhs) 
{ 
    // ... 
    return lhs = rhs; 
} 

Questo funziona per i tipi definiti dall'utente (perché operator= volontà essere membro della funzione ) e alcuni membri volevano supportarlo per i tipi predefiniti come . Quindi la regola base è diventata: se un operatore ha richiesto un operando lvalue , che ha modificato, e, i risultati dell'operatore sono stati l'operando modificato , quindi è un lvalue. (Così, mentre il prefisso ++ è un lvalue, postfix non è, perché i risultati dell'espressione non sono la cambiato operando.)

Personalmente, io non sono sicuro sono d'accordo. Non ho alcun problema con la sostituzione del sopra con:

T& 
someFunction(T& lhs, T const& rhs) 
{ 
    // ... 
    lhs = rhs; 
    return lhs; 
} 

che è come mi piacerebbe scrivere nel mio codice.Ma dato che il primo esempio è legale per i tipi definiti dall'utente (dove operator= restituisce a T&) e che a un certo numero di membri del comitato piace, sembra che sia logico estenderlo ai tipi predefiniti e il conseguente la regola è coerente, anche se nessuno ha mai avuto l'occasione di utilizzare i risultati come prefisso .

EDIT:

Giusto per chiarire: ho chiesto a questa domanda in uno dei incontri (quando stavamo definendo C++ 98), e questo è stato la risposta ho ricevuto (da, se ricordo correttamente, Andy Koenig, il quale ha lavorato con Stroustrup sulle prime implementazioni di C++). Era anche la giustificazione per l'implementazione predefinita di di operator= restituire uno T& anziché uno T const&.