StackOverFlow in Postfix Decrement in JAVA

Question

This works fine because we are using the prefix decrement operator in the recursive call !

public static void main(String[] args) {
    doubt1(5);
}

Prefix Decrement:

static void doubt(int num)
{
    if(num==0)
        return;
    System.out.println(num);
    doubt(--num);
}

Postfix Decrement:

static void doubt1(int num)
{
    if(num==0)
        return;
    System.out.println(num);
    doubt1(num--);
}

But when we use the postfix decrement it can lead to stack over flow error , I understand why it's causing the error , but I want to know , if we use num-1 in the recursive call it doesn't give the overflow error , my question is -> why it's not giving the error coz it calculating the num-1 and passing the value to the recursive call but not calculating the num-- in the call ?

Want the explanation why it calculating the num-1 not num-- in the recursive call ? Not why it's happening !

Lets say num is 5. doubt(num--) is same as calling doubt(5), whereas both of doubt(num-1) and doubt(--num) are the same as calling doubt(4) and num inside the nested call is now 4... and so on — DuncG
– DuncG, Commented May 20, 2023 at 14:49

Thomas Kläger · Accepted Answer · 2023-05-20 14:47:16Z

2

    doubt1(num--);

is internally implemented as

    int tmp = num;
    num = num - 1;
    doubt1(tmp);

That is, it recursively calls the doubt1 method with the original value and therefore the condition num == 0 is never reached.

answered May 20, 2023 at 14:47

Thomas Kläger

22k3 gold badges31 silver badges40 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

John Bollinger · Accepted Answer · 2023-05-20 14:55:36Z

When you invoke a method, the arguments are evaluated, and the resulting values are assigned as the initial values of the method's parameters. The expressions num-- and --num have the same side effect on num, but that is immaterial to the method invocation. The two evaluate to different values: the former to the value of num before it is decremented, and the latter to the value of num after it is decremented. The order of the operator relative to the operand is mnemonic for that.

Thus, with

int n = 1;
some_method(n--);

the value passed to some_method() is 1, but with

int n = 1;
some_method(--n);

the value passed to some_method() is 0.

In both cases, however, the value 0 is stored in n before execution of the body of some_method() commences.

Reilas · Accepted Answer · 2023-05-20 18:25:43Z

First, with the unary decrement operator, the operation is occurring after, or before, the statement.
As opposed to after, or before, the expression.

So, in this situation, there will be a difference between num-- and --num.

doubt(num--) is decrementing after the call statement, and not after the parameter expression.
double(--num), the opposite is happening, the decrement is happening before the parameter expression.

Essentially, from a compiler's stand-point, for the doubt(--num) statement, you have the following.

Get num
Decrement num
Apply num as doubt parameter
Execute doubt with parameter value

Alternately, with doubt(num--) you have the following.

Get num
Apply num as doubt parameter
Decrement num (which has no effect, since the parameter value was already set)
Execute doubt with parameter value

Essentially, for the doubt(num--) statement, after the compiler has num, and is ready to call doubt, it will then decrement num.
As opposed to having num, then decrementing, and then calling doubt.

Collectives™ on Stack Overflow

StackOverFlow in Postfix Decrement in JAVA

3 Answers 3

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related