DIP 1014

Stanislav Blinov stanislav.blinov at gmail.com
Wed Oct 3 19:21:14 UTC 2018


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 at 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.


More information about the Digitalmars-d mailing list