C++ constructors, destructors and operator access

[evilrat]

On Saturday, 18 May 2013 at 22:23:51 UTC, Igor Stepanov wrote:
> At the current time D have powerful mechanism of access to C++ 
> classes.
> For access to methods of C++ classes (virtual and not) we can 
> use extern(C++) interface.
>
> //С++
>
> class CPPTest1
> {
>     int a;
>     int b;
>   public:
>     virtual int boom();
>     int fun();
>     static int gun();
>     CPPTest1(int);
>     virtual ~CPPTest1();
>     int& operator[](size_t);
> };
>
> class CPPTest2: public CPPTest1
> {
>     int boom();
> };
>
> //D
> extern(C++)interface CPPTest1
> {
>     int boom();
>     static int gun();
>     final int fun();
> }
>
> extern(C++)interface CPPTest2: CPPTest1
> {
>     //int boom();
> }
>
>
>
> As a rule, non-static fields are not public in C++ classes and 
> is not part of interface. Thus the most of C++ classes can be 
> bound without any glue c++ code.
> However D dont support C++ overloaded operators and 
> constructors. Yes, we cannot make mapping C++ operators to D 
> operators and C++ constructors to D constructors). Nonetheless 
> С++ operators and constructors are the simple C++ functions or 
> methods with special mangling. Thus I've suggest next mechanism:
> Allow special pragma(cppSymbol, string_arg), when string_arg is 
> the name of c++ thing.
> Example:
>
> extern(C++)interface CPPTest1
> {
>     int boom();
>     static int gun();
>     final int fun();
>     ///!!!!
>     pragma(cppSymbol, "constructor") final void ctor(int); 
> //linked with CPPTest1(int);
>     pragma(cppSymbol, "destructor") void dtor(); //linked with 
> virtual ~CPPTest1();
>     pragma(cppSymbol, "[]") ref int indexOf(size_t); //linked 
> with int& operator[](size_t);
> }
>
> This pragma must apply to the function (or method), use natural 
> C++ mangle, but set operatror or constructor or destructor 
> mangled name instead of function name.
>
> Is it useful idea?

you can do this yourself just with mixins and templates, but the 
real problem is c++ abi and name mangling. so you will need to do 
runtime search for c++ mangled names and which runtime used, get 
it and call placement new and ctor(with the help of asm{} of 
course), do the same for other operators. it is possible, but 
this is never be safe at least due to non-standardized name 
mangling.

you can write small library which would help doing this all if 
you really want this.