Envolver objeto de C++ en extern "C"

Question

consideran un simple clase de ejemplo:

class BankAccount { 
public: 
    BankAccount() { balance =0.0; }; 
    ~BankAccount() {}; 
    void deposit(double amount) { 
     balance += amount; 
    } 
    private: 
     double balance; 
}; 

Ahora digo que quiero terminar con esto en extern "C", por lo que se puede llamar de muchas diferentes lenguajes de programación como C# y Java. Probé la continuación de lo cual parecía funcionar:

// cbankAccount.h: 
extern "C" unsigned long createBackAccount(); 
extern "C" void deposit(unsigned long bankAccount, double amount); 
// cbankAccount.cpp 
unsigned long createBackAccount() { 
    BankAccount *b = new BankAccount(); 
    return (unsigned long) b; 
} 
void deposit(unsigned long bankAccount, double amount) { 
    BankAccount *b = (BankAccount*) bankAccount; 
    b->deposit(amount); 
} 

Es este portátil? ¿El tipo sin signo "sin signo largo" es lo suficientemente grande para un puntero de objeto? ¿Algún otro problema con este enfoque?

¡Gracias de antemano por cualquier respuesta!

Answer 1

Que básicamente se ve bien con una condición. Intentar utilizar un tipo de entero para contener un puntero no es una gran idea; es mucho mejor usar void* ya que, por definición, es el ancho de un puntero.

---

En realidad, creo que la respuesta de @ DeadMG es un enfoque más limpio que este.

Answer 2

Esto no es portátil, porque unsigned long puede no ser suficiente para un puntero. Una plataforma no tan rara donde sucede esto es win64.

Es mejor usar ptrdiff_t o void*.

Answer 3

Sí. Es malo. Muy mal. unsigned long - simplemente no. Devuelve un BankAccount* correctamente tipado; los otros idiomas lo verán en el otro extremo como un puntero genérico (como System.IntPtr) y no es necesario devolver un puntero sin tipo cuando la interfaz binaria no escribe punteros de todos modos.

extern "C" BankAccount* CreateBankAccount() { 
    return new BankAccount; 
} 
extern "C" void deposit(BankAccount* account, double amount) { 
    account->deposit(amount); 
} 

Answer 4

Probablemente sería dependiente de la plataforma ya sea larga es lo suficientemente grande (probablemente no en x86-64) una alternativa es usar algo como swig

Answer 5

que haría uso de void * en lugar de largo sin signo.

Answer 6

Type-strong es incluso mejor que void *.

typedef struct BankAccountProxy * BankAccountPtr; 

BankAccountPtr createBackAccount() { 
    BankAccount *b = new BankAccount(); 
    return (BankAccountPtr) b; 
}