There are three things that might be suspicious for you if you are a C++ beginner:

First thing might be operator /=, which combines an integral division (i.e. without remainder), with an assignment. So x /= 10 actually is the same as x = x / 10.

Second, each expression in C++ has - after having been evaluated - a value. For an assignment like (x = 0), the result is the value of x after the assignment, i.e. 0 in this case.

Third, a condition like if (x) ... with x being of integral type has in C++ the same meaning as if(x != 0), i.e. it is false if x equals 0, and it is true if x is anything else but 0.

All together: while ( x /= 10 ) means assign x the value of an integral division by 10 and then compare the value to 0. If 0 is reached, the loop ends.

BTW: length starts with 1, because any number, even 0, comprises at least one digit.

x /= 10 continuously divides x by 10, which will make it 0 eventually and cause the while loop to terminate due to 0 being interpreted as false (and any other value than 0 as true).

The reason it starts at length = 1 is because there is always at least 1 digit in the number: if x was from 0 to 9 inclusive, then x /= 10 would cause x to become 0 immediately, meaning nothing inside the loop would execute. Therefore, if length started at 0, it would never get to be incremented to 1 which would be wrong if x was a single digit large.

Manually calculating this example by hand:

1. 234567545 / 10 = 23456754, which is true, so the while loop continues and length becomes 2.




2. 23456754 / 10 = 2345675, true. length becomes 3.




3. 2345675 / 10 = 234567, true. length becomes 4.




4. 234567 / 10 = 23456, true. length becomes 5.




5. 23456 / 10 = 2345, true. length becomes 6.




6. 2345 / 10 = 234, true. length becomes 7.




7. 234 / 10 = 23, true. length becomes 8.




8. 23 / 10 = 2, true. length becomes 9.




9. 2 / 10 = 0, false. The while loop stops with length equal 9.

The loop

while (x /= 10) {

  length++;

}

will go until the result of x /= 10 evaluates to false, since 0 means false it will go until x /= 10 is 0. Integer division truncates, ensuring the condition will be reached. This can be illustrated by adding a simple debug statement, i.e.

while (x /= 10) {

  length++;

  std::cout << length << " " << x << std::endl;

}

Which outputs

2 23456754

3 2345675

4 234567

5 23456

6 2345

7 234

8 23

9 2

Integer division will truncate the remainder, so continually dividing a number with integer division will inevitably result in zero.

Dividing a number n by 10 while incrementing a counter i once for each time the resulting quotient (stored back into n) is not zero will result in the i containing the number of digits for the base-10 representation of n.

It helps to understand two parts:

• what is "/="


• when does the loop terminate

Explain "/="

This:

x /= 10

is the same as:

x = x / 10

Explain when the loop terminates

The while loop terminates, when the condition is false. And 0 is equivalent to false.

while (condition) {

    length++;

}

So x is, with every pass through the loop, divided by 10, until is is 0. That terminates the loop.

So, the condition is two things at the same time:

• it is a value, that is compared to 0. The loop continues until this
  evaluates to 0.


• it is an assignment: x gets a new value with every evaluation. It's divided by 10, so it converges to 0.

This is a bit of stupidity you'll often see in C/C++, taking advantage of the fact that TRUE is implemented as non-zero, and FALSE as zero*. So x is repeatedly divided by 10, and the expression eventually becomes zero, so the loop stops.

Though confusing, this works - until the day someone in a hurry changes x from an int to a double :-) Much clearer and less failure-prone to write "while (x /= 10 >= 1)", or even to put the math inside the loop body rather than in the condition.

*IMHO one of the few shortcomings of C is that it didn't have an explicit logical type, as FORTRAN did.