Is the short-hand `+=` the only way to update a variable in this program?

Question

I was trying to make a program that finds us the sum of the cubes of the digits of a number using the concept of recursion.

But something weird happens when I try to add the numbers and update the variable sum. When I write

sum = sum + pow(sumCube(num), 3);

the values aren't added and stored in sum. Instead, the values in sum are overwritten as if the value of sum were reset to 0 every time.

On the other hand, when I write

sum += pow(sumCube(num), 3);

the program seems to run perfectly. Here is the program for your reference.

#include <iostream>
#include<math.h>
using namespace std;

int num = 51, dgt = 0, sum = 0;

int sumCube(int)
{
int dgt = num % 10;
while (num > 10)
{
    num = num / 10;
    //sum = sum + pow(sumCube(num), 3);    //doesn't work properly
    sum += pow(sumCube(num), 3);         //works properly
}
cout << sum << endl;
return(dgt);
}
int main()
{
    num = num * 10;
    sumCube(num);
    return 0;
}

I think the syntax is what's causing the problem. But I've also viewed a few posts that say both the syntaxes behave the same way. I never had such a problem before, both the versions seemed to work the same way.

Any help is appreciated.

Answer 1

The overall approach to the recursion is completely wrong.

1. Mutating global state is a bad idea even in the best conditions. It's especially important to avoid that when using recursion, because it makes it much harder to reason about the code correctly.

2. Functions should normally signal the result of the calculation by returning it. This is especially important for recursive functions. That's what return is for.

3. The point of using recursion here (admittedly a trivial example) is that it already decomposes and simplifies the problem at each step: we use the recursion to find the sum of all the other cubes, and then add the cube for the current digit. Therefore, the correct recursive code should not have a while loop.

4. Please make sure you have a solid understanding of how calling a function works. Writing int sumCube(int) { means that the function accepts a parameter, but can't use it because there is no name for it. We should write a name: int sumCube(int num) {. Then, only inside the function, num is a name for whatever was passed in as an argument. This does not have to be another variable named num; it does not have to be a variable at all. We do not pass variables to functions. We pass values to functions.

You know, exactly like how when you write pow(sumCube(num), 3), the 3 didn't have to be a variable at all, and didn't have to have a name dictated by the pow function. Exactly like how when you use the pow function, it returns a value that you can use on the right-hand side of +, and doesn't change any global variable.

---

With that background in mind, we can approach the problem fresh. Think about it this way: imagine that you had someone else's function, sumCube2, which solves the same problem in some other way. We want to use it to help solve the problem. What is our general approach?

1. We want to give sumCube2 a simpler problem than the one that we got (or else we could have just used it directly). We have a decomposition step already: we use division and modulo to extract the last digit.

2. We want to combine the result from calling sumCube2, with some local calculation. It's easy to see how to do this: we cube the last digit, and add the result from the function call to that cubed value. Then we can return that result.

3. We need to guard against the problem of running out of room for simplification. This is simple: if we're given 0, then we know the result is 0, and we don't have to do any more work. (There are other ways to implement this step, but why make it any harder?)

So: We need a function that accepts a parameter named num:

int sumCube(int num) {
    int last, rest;

We will first check our special case:

    if (!num) return 0;

Otherwise, we extract the last digit, and separate the rest of the number:

    last = num % 10;
    rest = num / 10;

We compute and return the result, by making use of the sumCube2 result:

    return sumCube2(rest) + pow(last, 3);
}

Notice that we don't need to modify any global variables, use a while loop, or anything like that.

We can condense the code a little bit, since we don't really need names for those intermediate calculation results (that was just to be able to talk about the logic one step at a time):

int sumCube(int num) {
    if (!num) return 0;
    return sumCube2(num / 10) + pow(num % 10, 3);
}

(Or we could use a ?: conditional expression, or we could use multiplication explicitly instead of calling pow, you get the idea.)

Now, how do we make this use recursion, and not have to depend on the mythical sumCube2 that we didn't write?

Simple: sumCube is a function that is intended to do exactly what sumCube2 was going to do. So we just call it instead - i.e., make the recursive call there.

int sumCube(int num) {
    if (!num) return 0;
    return sumCube(num / 10) + pow(num % 10, 3);
}

It works because every call to the function gets its own parameters and its own local variables, and returns back to where it was called from - exactly like calling any other function. Because we only expect the recursive call to do part of the work, and because we only recurse when there is a valid "part of" the work to do recursively, we avoid infinite recursion.

Notice that I do not have any cout logic in this code. That is because the purpose of sumCube is to compute the sum of the cubes. Displaying that result is a completely separate and unrelated task. It is the responsibility of main:

int main()
{
    cout << sumCube(51) << endl;
    return 0;
}

Answer 2

The basic problem is that in this expression:

sum + pow(sumCube(num), 3)

the value of sum might be read either before or after calling sumCube -- there's no sequence point here and no dependency between them. Since sumCube also modifies sum (it's a global variable), you get indeterminate behavior.

When you use the += operator, there's a dependency between its left operand and its right operand (as there is with any assignment), so the call to sumCube will come before the addition which reads the value of sum, so you'll always get the value of sum after it has been modified by sumCube