在C中的while循环条件中使用赋值运算符

Question

The question is:

Rewrite the following C code in a more readable style:

while (*dst++ = *src++);

I want to check that I am understanding this line correctly. By assigning *src to *dst, it is checking if *dst (and, by extension, *src) is a non-zero (or zero) value. If non-zero, the while body is executed, otherwise it is skipped.

My answer, based on the above understanding:

*dst = *src;
while (*dst) {
   [do stuff]
   *dst++;
   *src++;
   *dst = *src;
}

I realize that the position of the post-increment for both variables is important for a real program, but I don't think it matters here.

Answer 1

Yes this is exactly what is being done ( char s are copied along with null terminator) on the one-line code. But in your code

*dst++;
*src++;

can be replaced by

dst++;
src++;

You have dereferenced it unnecessarily .

To explain a bit further the value assigned is the value of the assignment expression which is being checked in the while condition which when turns out to be \\0 terminates the loop but the \\0 is copied in the dst also.

The implementation you wrote also will do one check and one assignment even if it is empty string just like the original one.

And yes in your case, the post increment or pre increment doesn't matter but in original implementation it does .

By the last line I meant, ++dst;++src; will be same as dst++;src++; in your case.

But in original implementation if you have used

*++dst = *++src

This would be wrong and meaningless for the purpose of copying. Think of the case when it is empty string. You will access array index out of bound.

---

 while(*dst++ = *src++); 

This is readable - in fact for the second code you wrote I have to think twice of the edge cases - here it is clean simple logic. Less code Less confusion. Readability doesn't mean more code - it is the clean code which is more readable.

Answer 2

As you may know, the original loop is a common C idiom for copying a zero-terminated string. Any C programmer should recognize it at a glance. So in that sense it it already quite readable.

The revised version is harder to understand, with the repeated assignment outside and inside the loop.

If you want to write it out step by step in the most detailed manner possible, while also keeping exactly the same behavior as the original, I suggest this, assuming that src and dst are char* pointers.

// This extra pair of curly braces keeps the `char c` local to this code
{
    char c;  // Change this if the type is different
    do {
        c = *src;
        *dst = c;
        src = src + 1;
        dst = dst + 1;
    } while( c );
}

BTW one problem with the original is that many modern C compilers will issue a warning on the assignment, the idea being that it may be a typo for an intended == comparison. You can usually suppress this warning with an extra set of parentheses:

while(( *dst++ = *src++ )) ;

Answer 3

   *dst++;
   *src++;

is same as

   *dst; <<dereferencing for no use. 
    dst++;  
   *src; <<dereferencing for no use.
    src++;

Answer 4

By assigning *src to *dst, it is checking if *dst (and, by extension, *src) is a non-zero (or zero) value. If non-zero, the while body is executed, otherwise it is skipped.

That's correct as far as it goes, but as far as the purpose of such code goes, it misses the point. A high-level description of the function of the code would be: copy successive elements of the array pointed into by src to successive elements of the array pointed into by dst until an element with value 0 has been copied. In particular, if src and dst are pointers to char then this is a possible implementation of the strcpy() function.

But your characterization does not describe all the effects of the code, which include incrementing the src and dst pointers to one position past the last element copied. Your version does not match this. Moreover, your version is a bit odd in how it performs the pointer increments, in that after it performs the increments, it pointlessly dereferences the new pointer values and ignores the results. That's not good style.

There are a lot of alternatives that I would consider more readable, but your instructor may be looking for some particular characteristics. I expect first of all that they would want a version that does not use an assignment expression in boolean context. I imagine that they would also want to see the pointer dereferences and pointer increments performed in separate expressions. Here's a version that has those characteristics, that produces all the side effects of the original code, and that minimizes code duplication:

do {
    *dst = *src;
    dst++;
    src++;
} while (*(src - 1));

Answer 5

Your understanding of what the loop does is correct, but not your understanding of the post-increment, the post-increment has higher precedence than the *, so in the original while loop the post-increment increments the pointers (returning the original values), then dereferences those pointers assigning original *src to original *dest.

I suggest doing it as a for loop (although the original is already highly idiomatic):

for( ; *dst = *src; ++dst, ++src)
{ }