通过别名定义前向定义的C ++结构

Question

I want to write a C-wrapper around an existing C++ codebase. So I need to implement some C-API functions that merely forward their operations to the corresponding C++ methods.

My problem is, I cannot figure out how to implement a forward-defined struct by means of an existing class:

//Foo.hpp
namespace myLib {
  struct Foo {
    //some meaningful C++ body
  };
}

//foo.h
//#ifdef __cplusplus etc. left out
extern "C" {
  struct myLib_foo;

  myLib_foo* mkfoo();

  //etc.
}

//foo.cpp
extern "C" {
  #include "Foo.hpp"
  #include "foo.h"

  typedef myLib_foo myLib::Foo;  //this does not work

  myLib_foo* mkfoo() { return new myLib::Foo(); }
}

In this situation, the C-API can and shall only work with pointers to myLib::Foo , which obviously works well, if I define myLib_foo as a new struct inside foo.cpp. I guess it also works, if I define a struct myLib_foo somewhere else. Yet, since I want to keep my namespaces manageable, I am searching a way to define myLib_foo to be equivalent to some existing (and completely defined) struct. This, however does not work, since my compiler refuses the code above with "typedef redefinition with different types". Apparently, it distinguishes between type-aliases and structs.

Is there even a way to achieve what I want or does C++ have no means for real type-aliases?

edit: By the answer below, I figured I can use inheritance plus static_cast:

//foo.cpp
extern "C" {
  #include "Foo.hpp"
  #include "foo.h"    

  struct myLib_foo : public myLib::Foo {};  //this does work

  myLib_foo* mkfoo() { return static_cast<myLib_foo*>(new myLib::Foo()); }
}

Answer 1

The C code does not ever need a definition of the struct myLib_foo that it sees.

It handles it only through pointers and functions.

On the C++ side a simple implementation is a struct containing a pointer to the "real" object that it represents. You then define it in the ordinary way (in the C++ code), but of course with the name already established for the C code usage.

If you want to avoid even that little inefficiency, to hand out real object pointers to the C code, well then you have essentially two options:

• reinterpret_cast , or

• static_cast with the not-quite-C struct as a (possibly empty) base class.

But I would go for the simple implementation of myLib_foo as a struct with a pointer to the real one. The KISS principle: Keep It Simple, Stupid ^* . On second thoughts , to avoid allocation and deallocation issues, and to also avoid a formal dependency on the compiler (even if that would just be academic, a formality), I would go for the static_cast . For thinking about what it all entails, this seems simplest.

---

^{*: Oh, the last few times I mentioned this principle on SO, those answers were heavily downvoted. That has also happened when I have (correctly) proposed macros as solutions. I think one should be technically honest and ignore the general SO readership, so I mention it anyway.}