2012-04-10 17 views
6

C++ fa molto affidamento sullo stile C per esportare e importare le funzioni (non le classi/interfacce se ce n'erano) perdendo così l'aroma orientato agli oggetti che in molti modi rende criptica l'interfaccia esportata.Programmazione D: interfaccia ai limiti dei componenti

È possibile utilizzare il linguaggio di programmazione D per esportare le interfacce in uno stile orientato agli oggetti. Posso avvolgere classi C++ (pure) con interfacce D? Quali sono gli elementi possibili da considerare? Questo approccio è fattibile.

risposta

5

È possibile trovare una panoramica rispetto allo spettro di interoperabilità C++ di D's here.

orientata agli oggetti interoperabilità stile è fornita attraverso D's interface costrutto:

lato C++

#include<iostream> 

class I // Our interface-by-convention 
{ 
public: 
    virtual void foo() = 0; 

    void bar() // OK, non-virtual members do not affect binary compatibility 
    { 
     /* ... */ 
    } 
}; 

class C : public I 
{ 
private: 
    int a; 

public: 
    C(int a) : a(a) {} 

    void foo() 
    { 
     std::cout << a << std::endl; 
    } 
}; 

// This function will be used from the D side 
I* createC(int a) 
{ 
    return new C(a); 
} 

lato D

extern(C++) interface I 
{ 
    void foo(); 

    final void bar() // OK, non-virtual members do not affect binary compatibility 
    { 
     /+ ... +/ 
    } 
} 

// Link `createC` from the C++ side 
extern(C++) I createC(int a); 

void main() 
{ 
    I i = createC(2); 
    i.foo(); // Write '2' to stdout 
} 

D's extern(C++) sull'interfaccia I provoca la disposizione dell'interfaccia di replicare il layout di una classe C++ a ereditarietà con funzioni virtuali in t Compilatore C++ del compagno.

Lo stesso attributo nella dichiarazione di funzione createC fa sì che la funzione replichi la convenzione di manipolazione e chiamata di una funzione equivalente nel compilatore C++ complementare.

Coppie di compilatore companion: DMD/DMC++, GDC/g ++, LDC/Clang. È spesso possibile interagire con un compilatore non companion attenendosi alle funzioni virtuali e al C ABI per le chiamate alle funzioni dirette.

Si noti che la funzione createC restituisce I* in C++ e solo I in D. Ciò è dovuto al fatto che le interfacce e le classi D sono tipi di riferimento impliciti.

In uso più tipico del mondo reale, la funzione createC è più probabile che sia extern(C) di extern(C++) (e quindi extern "C" sul lato C++), per una maggiore interoperabilità tra i compilatori, o più tempo di esecuzione straight-forward che collega quando si utilizzano le DLL.

extern(C++) ha attualmente alcune limitazioni; al momento non è possibile dire a D quale spazio dei nomi è presente una dichiarazione extern(C++), limitando D a essere solo in grado di collegarsi ai simboli C++ nello spazio dei nomi globale.

Problemi correlati