Perché l'operatore di incremento post non funziona su un metodo che restituisce un int?

Question

public void increment(){ 
    int zero = 0; 

    int oneA = zero++; // Compiles 

    int oneB = 0++; // Doesn't compile 

    int oneC = getInt()++; // Doesn't compile 
} 

private int getInt(){ 
    return 0; 
} 

Sono tutti int, perché non compila B & C? Ha a che fare con il modo in cui l'operatore ++ differisce da = 0 + 1;?

Invalid argument to operation ++/--

Answer 1

i++ è un'assegnazione a una variabile i.

Nel tuo caso, zero++ è equivalente a zero = zero + 1. Quindi 0++ significherebbe 0 = 0 + 1, che non ha senso, così come getInt() = getInt() + 1.

Più precisamente:

int oneA = zero++; 

significa

int oneA = zero; 
zero = zero + 1; // OK, oneA == 0, zero == 1 

---

int oneB = 0++; 

significa

int oneB = 0; 
0 = 0 + 1; // wrong, can't assign value to a value. 

---

int oneC = getInt()++; 

significa

int oneC = getInt(); 
getInt() = getInt() + 1; // wrong, can't assign value to a method return value. 

---

Da un punto di vista più generale, una variabile è un L-valore, nel senso che si riferisce ad una locazione di memoria, e possono quindi essere assegnati. L in L -value significa sinistro lato dell'operatore di assegnazione (cioè =), anche se L-valori possono essere trovati sia sul lato sinistro o lato destro dell'operatore di assegnazione (x = y per esempio) .

L'opposto è R-valore (R significa destra lato dell'operatore di assegnazione). I valori R possono essere utilizzati solo sul lato destro delle istruzioni di assegnazione, per assegnare qualcosa a un valore L. In genere, i valori R sono letterali (numeri, stringhe di caratteri ...) e metodi.

Answer 2

Sia B e C fanno il compilatore dicono:

unexpected type, required: variable, found: value

quindi non è possibile incrementare il valore, solo una variabile.

Answer 3

Perché, come indicato nel JLS:

The result of the postfix expression must be a variable of a type that is convertible (§5.1.8) to a numeric type, or a compile-time error occurs.

Answer 4

getInt() non è int

getInt() rendimenti int

++ operatore fa due cose increment + assignment

Quindi fo r ++ operatore per lavorare è necessaria una variabile per memorizzare il risultato dell'operazione di incremento che sia 0 e getInt() no.

Answer 5

Perché 0 è un rValue (ad esempio, è possibile utilizzarlo solo dalla destra dell'operatore di assegnazione) not a lValue.

++ l'operatore incrementa il valore e lo imposta su se stesso pertanto 0++ darà un errore.

Answer 6

Why doesn't the post increment operator work on a method that returns an int?

Perché è un metodo getter e non ha senso modificare un valore tramite getter.

---

int z = x + y++; 

è equivalente a:

int z = x + y; 
y = y + 1; 

quindi non è valida per avere qualcosa di simile:

int z = x + getY()++; 

che è equivalente a:

int z = x + getY(); 
getY() = getY() + 1; // invalid! 

Answer 7

0++

È equivalente a 0 = 0 + 1; e certamente non è possibile.

, ad esempio deve essere assegnato a l-value.

getInt()++;

Motivo simile qui.

Answer 8

Gli operatori pre e post funzionano solo su variabili o lvalue come vengono chiamati. lvalue è l'abbreviazione di valore sinistro, cioè qualcosa che può stare a sinistra in un compito. Nel tuo esempio:

zero = 1; // OK 
    0 = 1; // Meaningless 
    getInt() = 1; // Also meaningless 

// jk

Answer 9

post-incremento e preincremento possono applicare solo con l'aiuto del variable.So il primo caso di compilazione.

Answer 10

La mia risposta è del tipo "out of the box".

In caso di dubbi sull'utilizzo da parte dell'operatore, ritengo "quale sia la funzione di sovraccarico equivalente" di questo operatore?

I, so, che gli operatori Java non hanno l'overloading dell'operatore, è solo un modo alternativo per fare una soluzione.

In questo caso:

... 
x++; 
... 

dovrebbe essere letto come:

... 

int /* function */ postincrement (/* ref */ int avalue) 
{ 
    int Result = avalue; 

    // reference value, 
    avalue = avalue + 1; 

    return Result; 
} 

... 
postincrement(/* ref */ x); 
... 

E:

... 
++x; 
... 

... 

int /* function */ preincrement (/* ref */ int avalue) 
{ 
    // reference value, 
    avalue = avalue + 1; 

    int Result = avalue; 

    return Result; 
} 

... 
preincrement(/* ref */ x); 
... 

Quindi, sia, versioni di "++", lavoro di funzione che riceve un parametro variabile per riferimento.

Quindi, un valore letterale come "0 ++" o un risultato di funzione come "getInt() ++", non sono riferimenti di variabile.

Cheers.

Answer 11

Poiché la funzione return è un'espressione RHS e le operazioni di pre/post incremento/decremento possono essere applicate solo alle espressioni LHS.