On Wednesday, 3 October 2018 at 18:38:50 UTC, Manu wrote:
On Wed, Oct 3, 2018 at 7:00 AM Stanislav Blinov via
Digitalmars-d <digitalmars-d@puremagic.com> wrote:
Any function in D that has a signature of the form
ReturnType foo(Type x);
in C++ would have an equivalent signature of
ReturnType foo(Type&& x); // NOT ReturnType foo(Type x);
What are you talking about? Equivalent C++ is:
ReturnType foo(Type x);
C++ has rvalue references, move semantics are explicit. D doesn't
have any of that. Perhaps I wasn't quite clear in that above
statement though.
Given some type Bar, compare these two calls in C++ in D, and
tell me, which signature in C++ should correspond to D? I'm not
talking about ABI, I'm talking about semantics.
foo(std::move(bar)); // C++
foo(move(bar)); // D
remembering that D's move() doesn't call postblit.
void foo(Bar bar) wouldn't satisfy that last bit, would it?
Yes, the semantics are different, as in D the move occurs before
the call. But in D right now you *must* assume that the argument
may have been moved, with all the consequences the language
currently entails (and some of which the DIP attempts to
resolve), whereas in C++ you can be explicit about it via
overloading for rvalue references.
It's impossible to perform copy elision when passing an lvalue
by-value *to* a function, but that's a case where you depend on
move semantics.
Of course it's impossible. I'm not sure I understand your point
here.
Also, within the function that receives an argument by value,
you
depend on move to construct something with that argument.
Type&& passes a reference, which means you can perform the move
direct from source to destination, without a stop at the middle
man.
Yup, no argument there.
