Trimming a string, why is there a semicolon after while loop? - c

Question

So I was reading some code from my C-programming course, and came across to this question asking:
Trim the string: " make trim " into "make trim".
This was the code:
#include <stdio.h>
#include <string.h>
#define MAX 100
void trim(char *s) {
char *d = s;
while (isspace(*s++))
;
s--;
while (*d++ = *s++)
;
d--;
while (isspace(*--d))
*d = 0;
}
int main() {
char s[MAX];
gets(s);
printf("[%s] -> ", s);
trim(s);
printf("[%s]", s);
return 0;
}
So, what I want to ask is, what are
while (isspace(*s++))
;
s--;
while (*d++ = *s++)
;
d--;
while (isspace(*--d))
*d = 0;
the incremented string (*s++), the ; after the while() loop doing, and how do they work?
Thanks in advance

Answer 1

The empty body is simply because the condition of the while has a side effect so the whole loop is encapsulated in the condition and there is nothing to put in the body.
So:
while (isspace(*s++))
;
Is the same as:
while (isspace(*s)) { s++; }
They put the semicolon on the extra line to make it clearer that the loop is empty (otherwise you might think the next real statement is part of the loop). Other people might put a comment there as well, or even rewrite it to avoid the body being empty.
Code with some descriptive comments:
This loop picks up each character in turn, increments s to point to the next and continue doing that until the character we picked up is not a whitespace character. Note that because it increments before the test it will increment s one time too many, so that's why there's a decrement after the loop ends.
while (isspace(*s))
;
s--;
This would have been equivalent and doesn't need the separate decrement:
while (isspace(*s)) { s++; }
This loop copies each character from s so starting at the first non-whitespace character to d which points initially at the start of the string. If there was no leading whitespace it copies the character directly on top of itself. The loop ends after we copied a null character, i.e. the end of the string. As before there is one increment too many so we have to decrement d to endpointing at the null character:
while (*d++ = *s++)
;
d--;
This loop decrements d and then picks up whatever character it now points at. If it is a whitespace character then it replaces it with a null character. Note that there is no check for hitting the start of the string, so if the initial string was empty (i.e. a single null character) it will happily work backward through memory corrupting bytes outside the string as long as they are whitespace:
while (isspace(*--d))
*d = 0;

Answer 2

You can rewrite:
while (condition);
as follows:
while (condition) { /* empty block */ }
If the condition contains statements to be executed these will be executed and evaluated as long as the condition meets, this is the case in your example.
1.
In your case the first while loop:
while (isspace(*s++));
loops until it founds the first character being no space (which is the m of make in this case). As there is a postfix increment it will point to a of make:
" make trim \0"
^ ^
d| s|
2.
After that s is decremented (s--;) pointing at the start (m of make).
" make trim \0"
^ ^
d| s|
3.
The second while loop writes the string beginning with make to the beginning of the character buffer because d is pointing to the beginning due it's set at the beginning of the function (char *d = s;). This is done until the null terminator '\0' is reached:
while (*d++ = *s++)
could be rewritten as:
while ((*d++ = *s++) != '\0')
and will result in (note that null terminator '\0' is also written):
"make trim \0 \0"
^ ^
d| s|
4.
Now d will be decremented (d--;) pointing at the space before the null terminator '\0'.
"make trim \0 \0"
^ ^
d| s|
5.
The last while loop will search for the first character being no space (with d) but in reverse order:
while (isspace(*--d))
*d = 0;
It will write multiple null terminator '\0' until it find a character being no space.
"make trim\0\0\0\0 \0"
So the resulting string will be:
"make trim"
It isn't necessary to write multiple null terminator '\0' here but instead one null terminator '\0' would be enought after m of trim.

Answer 3

while (isspace(*s++))
;
is just equal to
while (isspace(*s++));
Don't let ; at a new line confuse you. All in all it is just a way to emphasize that this while loop does not have a body. And a while loop that has no body is performing until it's isspace(*s++) condition is false. Also isspace(*s++) it is an only calculation that should be done for this loop, so that is why there is no need to have a body for this loop.
When you read code like this it is easy to miss this ; and then you can make a wrong assumption that expression directly below the loop is a loop body, but just not surrounded by {}:
while (isspace(*s++));
s--;
while (isspace(*s++))
s--;
See the difference? In second example s-- is a while loop's body. To attract attention programmer can write:
while (isspace(*s++))
;
s--;
to clarify and emphasize his real intentions.