C what does if (!(dest++ = src++)) return ret mean?

Question

I'm trying to direct the strncat function. I understand most of it and can write this a diff way, but I can't figure out how to write a longer version of while (!(*dest++ = *src++)).

char *_strncat(char *dest, char *src, int n)
{
    char *ret = dest;
    while (*dest) /* same as: while (dest[0] !- '\0') */
    {
        dest++; /* w. each loop, array is shifted left until it's empty */
    }
    while (n != 0)
    {
         if (!(*dest++ = *src++)) /* <=========here */
            return ret;
        n--;
    }
    *dest = 0;
    return (ret);
}

Can someone show and explain how to expand that line so I can direct it and learn how it works? Thanks!

@TonyTannous No, it is intentional. The code is looking for null-terminator — Eugene Sh., Feb 23 '17 at 22:51
There's no `while (!(*dest++ = *src++))` in the code. What are you talking about? — Barmar, Feb 23 '17 at 22:51
@EugeneSh. So he's assigning the src in dest and once reaching Null he returns. — Tony Tannous, Feb 23 '17 at 22:54
http://stackoverflow.com/q/18481740/4743711 can be of interest for you. — Loreto, Feb 23 '17 at 22:54
@dbconfession: Misleading titles damage searchabiity of questions. Titles are not supposed to require "figuring out". — AnT stands with Russia, Feb 23 '17 at 23:28
Note that the `strncat()` uses `size_t`, not `int` --> `char *strncat(char * restrict s1, const char * restrict s2, size_t n);`. If code really used `int`, the loop should be `while (n > 0)`. — chux - Reinstate Monica, Feb 23 '17 at 23:44

Barmar · Accepted Answer · 2017-02-24T21:24:12.737

3

The line:

if (!(*dest++ = *src++))
    return;

can be expanded to:

char temp1 = *src++; // copy from *src to temp1 and increment src
char temp2 = (*dest++ = temp1); // Copy temp1 to *dest, increment dest, and also copy value to temp2
if (!temp2) return ret; // return if the value that was copied is a null byte

The use of post-increment is important here. It ensures that we copy from *src to *dest before the pointers are incremented. So to expand it further, it would be:

char temp1 = *src;
src = src + 1;
char temp2 = (*dest = temp1);
dest = dest + 1;
if (!temp2)
    return ret;

edited Feb 24 '17 at 21:24

answered Feb 23 '17 at 22:56

Barmar

741,623
53
500
612

I think postincrement part should be expanded too as it makes the most confusion as I suspect. – Eugene Sh. Feb 23 '17 at 22:57
@Barmar thanks! I'm working through this. When i hit `char temp2 = (dest = temp1);` it returns `error: assignment makes pointer from integer without a cast [-Werror=int-conversion] char temp2 = (dest = temp1);` – dbconfession Feb 23 '17 at 23:27
@dbconfession change that line to: `char temp2 = (*dest = temp1);` – Aaron Feb 23 '17 at 23:28
@Barmar Your first expansion output correctly but is failing one unit check. Your second expansion worked AFTER fixing with Aaron's suggestion. If you either fix first or remove it and make aaron's fix in the second expansion I will mark it as answered. – dbconfession Feb 23 '17 at 23:48
I'd appreciate it if you came back with the information about the unit test tomorrow. I'm not sure what the problem is with my first code. – Barmar Feb 23 '17 at 23:51
The only thing I see with your first example is a missing ; otherwise it should work. – Aaron Feb 24 '17 at 19:17
Thanks @AaronTaggart that's probably what it was. – Barmar Feb 24 '17 at 21:24

Aaron · Answer 2 · 2017-02-23T23:26:05.137

Basically it is copying the values of src into dest, incrementing, and then checking for null (or the null terminator). So you could expand it this way:

*dest = *src; // Copy the value
if (*dest == '\0') // Was it null?
    return; // We are done!
dest++; // go to next character
src++; // go to next character

One point of confusion might be coming from the use of an = rather than a ==. The = operator always returns the value that was assigned, this allows for daisy chains of assignment:

int a, b, c;
a = b = 0; // sets both a and b to 0
if (c = a) // sets c = a, then performs if(0) which is false.

Note: Technically the src and dest pointers are incremented even in the case of the return, so this would properly expand to the below, but that is just noise as to understanding what the code is doing:

*dest = *src; // Copy the value
if (*dest == '\0') // Was it null?
{
    dest++; // not really needed but happens
    src++; // not really needed but happens
    return; // We are done!
}
dest++; // go to next character
src++; // go to next character

Except that `dest++` and `src++` still happen even if `return` happens. — Dietrich Epp, Feb 23 '17 at 23:02
So you are correct that src and dest get incremented in that case, but it is a moot point as far as the algorithm is concerned (or understanding how the algorithm works). But I am impressed with that find! I updated the answer. — Aaron, Feb 23 '17 at 23:12

C what does if (!(*dest++ = *src++)) return ret mean?

2 Answers2

C what does if (!(dest++ = src++)) return ret mean?