如何使用模板化的C ++结构定义C-forward声明的不透明结构

Question

Given the C declaration of opaque type (cheader.h)

typedef struct internal_data * Opaque;

I want to declare "internal_data" as an instance of the template (cppheader.h)

namespace Lib {
template<typename T>
struct Internal {
    T data;
};

template<typename T>
Internal<T>* Initialise(T data) {
    Internal<T>* t = new Internal<T>();
    t->data = data;
    return t;
}
}

So that the following function compiles:

#include "cppheader.h"
#include "cheader.h"

int main(int argc, char** argv)
{
    Opaque o = Lib::Initialise(argc);
    return 0;
}

I can't modify the C header. The C++ header isn't exposed, so I can modify that one at will. The instantiated template needs to be POD. There are multiple opaque types on the C header that I omitted for simplicity. They are all supposed to dereference to instantiations of the C++ template.

I've tried

typedef Lib::Internal<int> internal_data;

and

struct internal_data : Lib::Internal<int> {};

but neither compiles.

Answer 1

From what I can make out, this looks something typical of the C to C++ and vice-versa API mapping.

Given that you can't change the C header file, the definition of Opaque is constrained and essentially can't be typed to any C++ constructs contained in C++ header file.

It's a little ugly in a purist sense, but you can use reinterpret_cast for this.

In the cppheader;

struct internal_data {};

template<typename T>
struct Internal {
    T data;
};

template <typename T>
Opaque map_internal(Internal<T>* p)
{
  return reinterpret_cast<Opaque>(p);
}

template <typename T>
Internal<T>* remap_internal(Opaque p)
{
  return reinterpret_cast<Internal<T>*>(p);
}

And then the internal Initialise changes to;

template<typename T>
Opaque Initialise(T data) {
    Internal<T>* t = new Internal<T>();
    t->data = data;
    return map_internal(t);
}

You don't mention anything around resource management, but the reverse of map_internal can be used to cast the Opaque back to Internal<T> for the corresponding delete when required.

Note: type safety is a concern here (wrt the reinterpret_cast ), but in this case the trade-off is type safety vs. interoperability. Because of strict aliasing, you should not attempt to access any data that may (in future) be in internal_data , it is there just to convert from and back to Internal<T> .

Worth noting here is cppreference , conversion 5, related to the C++ specification 5.2.10.

Any pointer to object of type T1 can be converted to pointer to object of another type cv T2. This is exactly equivalent to

static_cast<cv T2*>(static_cast<cv void*>(expression)) .

Live sample

Answer 2

If you don't want to reinterpret_cast<> , you can inherit from a dummy internal_data , ie

struct internal_data {};
template<typename T>
struct Internal: internal_data {
    T data;
};

When you need to access the data just down-cast from the pointer to your template type.

Answer 3

Maybe union would help?

template<typename T>
union InternalExtend
{
    Internal<T>* internal;
    Opaque opaque;
};

template<typename T>
Opaque Initialise(T data) {
    InternalExtend<T> ret;
    ret.internal = new Internal<T>();
    ret.internal->data = data;
    return ret.opaque;
}