Pourquoi l’opérateur de post-incrémentation ne fonctionne-t-il pas sur une méthode qui renvoie un int?

public void increment(){ int zero = 0; int oneA = zero++; // Comstacks int oneB = 0++; // Doesn't comstack int oneC = getInt()++; // Doesn't comstack } private int getInt(){ return 0; } 

Ils sont tous int, pourquoi B & C ne comstack-t-il pas? Est-ce à voir avec la façon dont l’opérateur ++ diffère de = 0 + 1; ?

Argument non valide à l’opération ++ / –

i++ est une affectation à une variable i .

Dans votre cas, zero++ équivaut à zero = zero + 1 . Donc, 0++ signifie 0 = 0 + 1 , ce qui n’a aucun sens, ainsi que getInt() = getInt() + 1 .

Plus précisément :

 int oneA = zero++; 

veux dire

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

 int oneB = 0++; 

veux dire

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

 int oneC = getInt()++; 

veux dire

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

D’un sharepoint vue plus général, une variable est une valeur L , ce qui signifie qu’elle fait référence à un emplacement de mémoire et peut donc être affectée. L dans la valeur L représente le côté gauche de l’opérateur d’affectation (c.-à-d. = ), Même si les valeurs L se trouvent soit du côté gauche, soit du côté droit de l’opérateur d’affectation ( x = y par exemple).

Le contraire est la valeur R ( R représente le côté droit de l’opérateur d’affectation). Les valeurs R ne peuvent être utilisées que du côté droit des instructions d’affectation, pour affecter quelque chose à une valeur L. En règle générale, les valeurs R sont des littéraux (nombres, chaînes de caractères …) et des méthodes.

Parce que comme indiqué dans JLS :

Le résultat de l’expression postfix doit être une variable d’un type convertible (§5.1.8) en un type numérique, ou une erreur de compilation se produit.

getInt() n’est pas int

getInt() renvoie int

++ opérateur fait deux choses increment + assignment

Donc, pour que l’opérateur ++ fonctionne, vous avez besoin d’une variable pour stocker le résultat de l’opération d’incrément que 0 et getInt() ne sont pas tous les deux.

Les pré et post opérateurs ne fonctionnent que sur les variables ou les lvalues ​​telles qu’elles sont appelées. lvalue est l’abréviation de valeur de gauche, c’est-à-dire quelque chose qui peut restr à gauche dans une tâche. Dans votre exemple:

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

// jk

Les deux B et C font dire au compilateur:

type inattendu, requirejs: variable, trouvé: valeur

Vous ne pouvez donc pas incrémenter une valeur, seulement une variable.

Pourquoi l’opérateur de post-incrémentation ne fonctionne-t-il pas sur une méthode qui renvoie un int?

Parce que c’est une méthode getter, et que changer une valeur via getter n’a pas de sens.


 int z = x + y++; 

est équivalent à:

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

il n’est donc pas valable d’avoir quelque chose comme:

 int z = x + getY()++; 

ce qui équivaut à:

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

0 ++

C’est équivalent à 0 = 0 + 1; et certainement ce n’est pas possible.

c. l-value à-d. qu’il faut lui atsortingbuer une l-value .

getInt () ++;

Raison similaire ici.

Parce que 0 est une valeur rValue (c’est-à-dire que vous ne pouvez l’utiliser qu’à partir de l’opérateur d’affectation), not a lValue .

++ opérateur ++ incrémente la valeur et la lui atsortingbue. Par conséquent, 0++ vous donnera une erreur.

postincrement et preincrement ne peuvent s’appliquer qu’à l’aide de variable.Ainsi, le premier cas est compilé.

Ma réponse est du genre “out of the box”.

Lorsque je doute de l’utilisation d’un opérateur, je pense “quelle est la fonction surchargée équivalente” de cet opérateur?

Je sais que les opérateurs Java n’ont pas de surcharge d’opérateur, c’est juste une solution alternative.

Dans ce cas:

 ... x++; ... 

devrait être lu comme:

 ... int /* function */ postincrement (/* ref */ int avalue) { int Result = avalue; // reference value, avalue = avalue + 1; return Result; } ... postincrement(/* ref */ x); ... 

Et:

 ... ++x; ... ... int /* function */ preincrement (/* ref */ int avalue) { // reference value, avalue = avalue + 1; int Result = avalue; return Result; } ... preincrement(/* ref */ x); ... 

Donc, les deux versions de “++” fonctionnent comme une fonction qui reçoit un paramètre variable par référence.

Donc, une valeur littérale comme “0 ++” ou un résultat de fonction comme “getInt () ++” ne sont pas des références variables.

À votre santé.

Comme la fonction retourne une expression RHS et que les opérations d’incrémentation / décrémentation pré / post peuvent uniquement être appliquées aux expressions LHS.