CODEWITHSUNDEEP
javapost-increment
Blundell
Blundell

Reputation: 76458

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

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;
}

They are all int's, why won't B & C compile? Is it to do with the way ++ operator differs from = 0 + 1;?

Invalid argument to operation ++/--

Upvotes: 62

Views: 6768

Answers (11)

xlecoustillier
xlecoustillier

Reputation: 16351

i++ is an assignment to a variable i.

In your case, zero++ is an equivalent to zero = zero + 1. So 0++ would mean 0 = 0 + 1, which makes no sense, as well as getInt() = getInt() + 1.

More accurately :

int oneA = zero++;

means

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

int oneB = 0++;

means

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

int oneC = getInt()++;

means

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

From a more general point of view, a variable is a L-value, meaning that it refers to a memory location, and can therefore be assigned. L in L-value stands for left side of the assignment operator (i.e. =), even if L-values can be found either on the left side or the right side of the assignment operator (x = y for instance).

The opposite is R-value (R stands for right side of the assignment operator). R-values can be used only on the right side of assignment statements, to assign something to a L-value. Typically, R-values are literals (numbers, characters strings...) and methods.

Upvotes: 150

Gaurav Phapale
Gaurav Phapale

Reputation: 979

Since function return is RHS expression and pre/post increment/decrement operations can be applied to LHS expressions only.

Upvotes: 0

umlcat
umlcat

Reputation: 4143

My answer its kind of "out of the box".

When I have doubt about an operator usage, I think "which its the overloaded function equivalent" of this operator ?

I, know, that Java operators doesn't have operator overloading, its just an alternative way to make a solution.

In this case:

...
x++;
...

should be read as:

...

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

  // reference value, 
  avalue = avalue + 1;

  return Result;
}

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

And:

...
++x;
...

...

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

  int Result = avalue;

  return Result;
}

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

So, both, versions of "++", work as a function that receives a variable parameter by reference.

So, a literal value like "0++" or a function result like "getInt()++", are not a variable references.

Cheers.

Upvotes: 1

Gijo
Gijo

Reputation: 249

postincrement and preincrement can apply only with the help of variable.So the first case compile.

Upvotes: 0

Arsen Alexanyan
Arsen Alexanyan

Reputation: 3141

Because 0 is a rValue (i.e. You can use it only from right of the assignment operator) not a lValue.

++ operator increments the value and sets it to itself therefore 0++ will give You an error.

Upvotes: 2

Eng.Fouad
Eng.Fouad

Reputation: 117587

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

Because it is a getter method, and it doesn't make sense to change a value via getter.

int z = x + y++;

is equivalent to:

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

so it is not valid to have something like:

int z = x + getY()++;

which is equivalent to:

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

Upvotes: 4

Apurv
Apurv

Reputation: 3753

getInt() is not int

getInt() returns int

++ operator does two things increment + assignment

So for ++ operator to work you need a variable to store the result of increment operation which 0 and getInt() both are not.

Upvotes: 14

j.karlsson
j.karlsson

Reputation: 653

The pre- and post- operators only operate on variables or lvalues as they are called. lvalue is short for left value, i.e. something that can stand to the left in an assignment. In your example:

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

//jk

Upvotes: 10

Azodious
Azodious

Reputation: 13872

0++

It is equivalent to 0 = 0 + 1; and certainly it is not possible.

i.e. it has to be l-value to assign to it.

getInt()++;

Similar reason here.

Upvotes: 3

PermGenError
PermGenError

Reputation: 46408

Because as stated in 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.

Upvotes: 29

user1907906
user1907906

Reputation:

Both B and C make the compiler say:

unexpected type, required: variable, found: value

So you can't increment a value, only a variable.

Upvotes: 5

Related Questions