``` target[i++] = source1[j++] + source2[k++]; ``` That's idiomatic, it shows the intent to read and consume the value in a single expression. You can write it longer, but not more clearly.
It's only when you assign to the same variable multiple times, or read it after it was assigned, that it introduces ordering issues.
A single `i++` or `++i`/`i += 1` is safe and useful.
Sure, and you don't need the assignment to be an expression with a value for it to be useful.
>target[i++] = source1[j++] + source2[k++]; That's idiomatic
That's idiomatic to C for sure.
Also idiomatically horrible. Why are you using three index variables here?
>You can write it longer, but not more clearly.
target[i] = source1[i] + source2[i];
i++;
You can't forget to increase one if the indices when all three are meant to go in lockstep.
It's longer by one semicolon, and requires far less cognitive overload to parse.
There's a reason why they did away with it in Go. What do you think that reason was if it's so useful?
> You can't forget to increase one if the indices when all three are meant to go in lockstep.
Obviously they are not in this example.
The next line might contain:
i++; j *= 42; k = srandom (k), random ();...of utter insanity which doesn't belong in any real world code.
It just keeps getting worse, and shows why it was a horrible idea to allow this in the first place.
>The next line might contain:
i++; j *= 42; k = srandom (k), random ();
You're already doing it there, why do you need to do an assignment inside the brackets?
(This was a rhetorical question. You don't).
It is useful to distinguish between consuming an element and only jumping to it. So you would have an ptr[i++] for consuming the current token, but not, when you are switching to another token.
A grouping of index and array modification also provides clarity about the intention. It would read very annoying if that constantly would be split into two steps, and also provides more room for error.
It's obvious that you do prefer the stylistic choices Go made, but that doesn't mean everyone does.
So, it's trivial to do it with a function. Or a macro.
int adv(int *i){
int t = *i;
(*i) = t + 1;
return t;
}
while(i < 10)
printf("%d\n", adv(&i));
The point is, you don't need assignment to return a value to have this.
Can you give a non-contrived example where you really need it?
>It's obvious that you do prefer the stylistic choices Go made, but that doesn't mean everyone does.
It's not that I "prefer stylistic choices of Go", it's that I hate to have undefined behavior in language spec which is easy to stumble into - the cost of the "stylistic choice" that C made doesn't make that choice justified.