How to wrap C++ class method having a parameter or returning an instance of another C++ class in C?

Question

I have a C++ class A having methods while some of them using an instance of another C++ class B as parameter and some are returning an instance of another C++ class C . How to correctly wrap in C language the class A and all of its methods?

I don't think that my question is a duplicate, since all the existing examples are showing C wrapper (header and source) for a simple C++ class with methods having parameters or return values of simple data type, like int , char* , etc.

class A {
  public:
    A(int param1);
    int getValue();
  private:
    int value;
}

// method B::DoSomething() has a parameter of type (class) "A"
class B {
  public:
    void DoSomething(A param1);
}

// method C::SetSomething() returns an instance of class "A"
class C {
  public:
    A SetSomething(int value);
}

I know how to write C-language wrapper for class A and its method: using the extern "C" {... } construct.

But how to do it for classes B and C and their methods?

Answer 1

The generic way is to create a wrapper for each C++ class and a method to generate pointers to those wrappers and another to delete them.

extern "C" {

struct WA{
    void* self;
};

struct WA* new_A( int p1 ){
    WA* wa = new WA;
    wa->self = new A( p1 );
    return wa; 
}

void delete_A( WA* wa ){
    delete static_cast<A*>( wa->self );
    delete wa;
}

}

Then you transform each method of each class into a function taking a pointer the struct as the first argument. A::getValue becomes

int A_getValue( WA* wa) {
    return static_cast<A*>( wa->self )->getValue();
}

Instances can be passed in via pointer, so B::DoSomething becomes

void B_DoSomething( WB *wb, WA *param1){
    static_cast<B*>( wb->self )->DoSomething( *static_cast<A*>( param1->self ) );
}

Likewise you can return instances by pointer. C::SetSomething then becomes

struct WA* C_SetSomething( WC* wc, int value ){
    A a = static_cast<C*>( wc->self )->SetSomething( value );
    return new_A( a.getValue() );
}

You will need to be very careful with your memory management in the C code. See working example here .

Answer 2

I suggest converting struct B and struct C into functions, since they have no members:

void B_DoSomething(A * p_param)
{
  //...
}

A C_SetSomething(int value)
{
  A variable;
  variable.value = value;
  return variable;
}

As a reminder, you should prefer to pass structures by pointer in the C language. Otherwise the compiler will generate copies (except when the compiler can optimize).

Answer 3

In almost all cases, you cannot .

Only if the struct is a POD, which means that it is a trivial & standard-layout type and that has no non-static members that are non-POD themselves.

This means, basically, that you can only use structs that are blobs of data without extra behavior and that C "understands" equally as C++.

The reason is simple: C has no idea of C++ semantics. For instance, if your class has a destructor, who is going to run it? Or, if your class runs some code when copied, how can C know about it?

You have two options:

• Share only those types. If you are unsure whether something is a POD or not, assert it (in C++):

   static_assert(std::is_pod_v<T>);

• Keep your classes, but pass opaque pointers to C. Since you are passing just pointers, C won't do anything with them.

Note that your example classes B and C are not PODs, so you cannot do it for those.