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.