C interface of C++ code: how to avoid "mismatched-tag" warning

Question

I need to wrap a C++ library with a C interface. My code goes like this small example:

mylib.cpp:

#include <iostream>

using namespace std;

class MyClass {
  public:
  void do_something() {
    cout << "this is something\n";
  }
};

// implementing C interface:

extern "C" {
  #include "mylib.h"
};

MyClass *lib_init() {
  return new MyClass;
}

void lib_release(MyClass *ptr) {
  delete ptr;
}

void do_something(MyClass *handler) {
  handler->do_something();
}

mylib.h:

struct MyClass;
typedef struct MyClass *MyClassHandler;

MyClassHandler lib_init();
void lib_release(MyClassHandler h);
void do_something(MyClassHandler h);

test.c:

#include "mylib.h"

int main() {
  MyClassHandler h;
  h = lib_init();
  do_something(h);
  lib_release(h);
}

Makefile:

mylib.o: mylib.cpp mylib.h
    g++ -Wall -c $< -o $@

test.o: test.c mylib.h
    gcc -c $<

test: test.o mylib.o
    g++ -o $@ $^

The test code works, but with clang and -Wall I obtain the following annoying warning:

./mylib.h:3:1: warning: struct 'MyClass' was previously declared as a class [-Wmismatched-tags]

I have found the following interesting informations:

Developing C wrapper API for Object-Oriented C++ code (how to wrap C++ library in C headers)

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61339#c6 (gcc developers believe that the warning raised by clang is stupid)

The question is: what is the best way to deal with this warning?

I see some possibility:

1. disable the warning with a #pragma in the header file

2. use struct also in the cpp file, paying attention to explicitly mark all data with appropriate public/private modifiers

3. wrap the class into a struct

4. change the paradigm used to implement the C interface (using, for example, a dummy struct and reinterpret_cast)

What's the best practice? Have you some reference to point out?

Answer 1

I think the best practice is to declare a new struct to hold the state of the library. That might look like:

// .cpp
struct MyLibHandle_ {
    MyClass my_class;
};

...

// .h
struct MyLibHandle_;
typedef MyLibHandle_ *MyLibHandle;

But usually it might actually have more than one class, e.g. it will also contain a logger instance or whatever. The rest is easy from there since you have struct in both C and C++. Do not reinterpret_cast, that always looks a bit suspicious. This is what I always went with and seen others do.

No way to know how it works inside, but OpenCL's idiomatic definition of an "opaque type" looks like this (taken from CL/cl.h):

typedef struct _cl_command_queue *  cl_command_queue;

Since the type is opaque for C, you might also do just:

#ifdef __cplusplus
class MyClass; // class for the C++ compiler
#else
struct MyClass; // struct for the C compiler
#endif
typedef MyClass *MyClassHandle;

That should work pretty much everywhere.