CODEWITHSUNDEEP
javamathincrementpost-increment
ctrlaltdel
ctrlaltdel

Reputation: 145

post-increment, pre-increment. JAVA

I understand the difference between this operations (post-increment, pre-increment). But question: I have an expression:

int x = 4;
long y = x * 4 - x++;

The highest priority has post-unary operator, than "*" and last "-". In my opinion it will be:

long y = x * 4 - x++;

1). x++ => return 4 (save x = 5)
2). final expression: 5 * 4 - 4 = 16

But when I compile this in IDE the answer is 12 ! What's a problem and where did I do smth. wrong?

Upvotes: 1

Views: 747

Answers (5)

Mark Melgo
Mark Melgo

Reputation: 1478

EDITED

Here are the steps to evaluate the expression:

  1. Evaluate all the expression that has increment/decrement from left to right
  2. Replace all variable with their true value
  3. Evaluate the expression using PEMDAS rule

Example:

int x = 4;   
int y = ++x * 5 / x-- + --x;

  • first we need to substitute all values of x before evaluating the expression (substitute from left to right)
    ++x -> since it is a post increment we will first increment x before substituting, thus x will be 5
    5 * 5 / x-- + --x -> this will be the new equation
    now we will substitute x in x--
    x-- -> since it is a post decrement x here will be substituted with 5 and after the substitution decrement x, thus x will be 4
    5 * 5 / 5 + --x -> this will be the new equation
    now we will substitute x in --x
    --x -> since it is a pre decrement we will first decrement x substituting, thus x will be 3
    5 * 5 / 5 + 3 // this will be the new equation

  • Since there are no variables in the equation we will now evaluate the expression using PEMDAS
    25 / 5 + 3 5 + 3
    8
    thus the result will be 8

Upvotes: 3

ave4496
ave4496

Reputation: 3028

long y = 4 * 4 - 4;

x will be incremented after this assignment

Everytime x is "called" with x++ it gets incremented after E.g.

    int x = 1;
    System.out.println(x++ + x++ * x++ + x++);
    // 1 + 2 * 3 + 4

Upvotes: 3

Leo Aso
Leo Aso

Reputation: 12493

The left side of a subtraction is always computed before the right side because subtraction is left associative i.e. 5 - 2 - 1 is (5 - 2) - 1, not 5 - (2 - 1).

This is why the multiplication happens before the increment. Associativity determines what happens first here, not precedence.

Upvotes: 1

Andronicus
Andronicus

Reputation: 26066

Multiplication is resolved separately, so x == 4. Incrementation occurs afterwards, so it's actually 4 * 4 - 4 == 12 and after this operation x == 5.

Upvotes: 1

nullPointer
nullPointer

Reputation: 4574

x evaluates to 4, and x++ evaluates to 4 as well, and then gets incremented to 5. So it's essentially 4 * 4 - 4 , which gives 12 as expected.

Upvotes: 2

Related Questions