LOL – the optimized code is essentially just constant return true… It figured out that those variables were never used elsewhere so it effectively did the swap at compile time and said, yep, this is a tautology, what a verbose way to spell “return true;” but humans are weird sometimes 😁

Interestingly, that’s basically the Python idiom for swap: b, a = a, b

void addComplimentaryItem(std::vector& items);
std::vector vec;
vec.addComplimentaryItem(); // UFCS

For something like swap you would need a UFCS that supports structured bindings, so that you can write:

[x, y].swap();

To my knowledge this isn’t even supported in D and Rust, which technically have UFCS.

[1] https://isocpp.org/blog/2016/02/a-bit-of-background-for-the-unified-call-proposal

That’s a bit similar to what C# does: if a function takes a parameter by reference, then a “ref” declaration must appear at the call site (in addition to its definition), e.g. you would have to write

std::swap(ref x, ref y);

to get that line to compile. I kinda wish C++ also did that.

Not such a silly thought! I couldn’t prevent myself from looking the non-optimized code, that really is incredible for such a small piece of source code! 🙂

We can mark the parameter as an r-value to make the intention clear and enforce compile time check.

Value addThis(Value&& x);

https://godbolt.org/z/NSrW4P

The final example of std::swap is an excellent one. I would personally say that it is purely because we are so used to the idiom that we “see” the parameters as being modified. It is one more thing to learn and one more complexity that creates a hazard.

Perhaps if we were to design a new language from scratch, taking into account all we have learned from the last few decades as C++ developers, this should be one of the first things we think about. Much food for thought for this guy here who writes shit compilers for a hobby 🙂

add_this(x,p1,p2);

making everything even more confusing.

When no good abstraction can be found, a simple solution is to enforce tagging in-out parameters as such on both sites:

void add_this(inout_t x, P1 p1, P2 p2);
add_this(inout(x), p1, p2);

Simple and refactoring efforts reduced to a minimum.

To enlarge the debate, here is a doubtful idea abusing operator overloading:

std::vector x;
x << add_this(2,3);

This requires a bit of boilerplate code to define add_this, but not that much:

struct AddThis {};
auto add_this(int a, int b) { return make_proxy(a,b); }
void operator<<(std::vector& x,const Proxy &p) { … }

with a proof-of-concept there: https://godbolt.org/z/S6PpYY