On Monday, 21 September 2015 at 07:45:48 UTC, Ola Fosheim Grøstad wrote:
On Monday, 21 September 2015 at 04:22:30 UTC, Paul O'Neil wrote:
I hope that this post will spur discussion / decisions / action binding C++ libraries into D. I think the language capabilities (e.g. extern(C++, namespace)) get really far and that the next big push needs to be on binding real libraries and tools to help.

How do you deal with overloading of *, &, &&, const *, const& etc?

I guess that the only thing that doesn't map directly to D is &&. The others look on the D side like this:
C++      -> D
T*       -> T*
T&       -> ref T
const T* -> const T*
const T& -> const ref T

I think that T&& actually looks like the T& calling convention ABI-wise. The difference being that T&& functions are mangled differently so that you can overload them. The challenge is to be able to select them from the overload set. Perhaps the path of least resistance (for now) is to generate a .cpp (not a header-only library) containing a wrapper for every function that takes T&&. For example:

// C++ wrapper:

// Wrapper for `vector<T>::push_back( T&& value )`

void push_back_from_rvalue(vector<T>& this_, T& to_be_moved)

// D side:

// Let's say we want to use some move-only type
// like std::thread and push it into a std::vector:
auto my_vec = stdcpp.vector.vector!(stdcpp.Thread);

// The case with rvalue temporary:
// my_vec.push_back_from_rvalue(Thread(&theadFunc));
// ^ creates a temporary Thread object
// and moves it into the vector::push_back call stack.
// Implemented like this:
// (invisible to the user:)
Thread __rvalue_tmp = Thread(&theadFunc);

The case with lvalue whose ownership is transferred:
auto lvalue_thread_obj = Thread(&theadFunc);

// lvalue_thread_obj is passed by mutable reference
// (invisible to the user:)
// Unsafe to use lvalue_thread_obj from now on...

Reply via email to