C++ constructors, destructors and operator access

[nazriel]

On Monday, 20 May 2013 at 20:11:27 UTC, nazriel wrote:
> 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?
>
> Isn't it possible already with something like:
>
> extern(C++) interface Foo
> {
>     pragma(mangle, typeof(this).mangleof ~ 
> generateCPPMangle!"myOwnFunctionMangling") void foo();
> }
>
Of course I mean:

extern(C++) interface Foo
{
     pragma(mangle, generateCPPMangle!(typeof(this).mangleof, 
"myOwnFunctionMangling")) void foo();
}

> AFAIK, mangle pragma was merged recently.