Allocate incomplete type on stack - c++

Question

I am working on wrapping a C++ library in C. The C++ library is a library for a database server. It uses a wrapper class for passing around serialized data. I can't use that class directly in C, so I defined a struct that can be used in C code like this:
In include/c-wrapper/c-wrapper.h (this is the wrapper that clients of my C wrapper are including)
extern "C" {
typedef struct Hazelcast_Data_t Hazelcast_Data_t;
Hazelcast_Data_t *stringToData(char *str);
void freeData(Hazelcast_Data_t *d);
}
In impl.pp
extern "C" struct Hazelcast_Data_t {
hazelcast::client::serialization::pimpl::Data data; // this is the C++ class
};
Hazelcast_Data_t *stringToData(char *str) {
Data d = serializer.serialize(str);
Hazelcast_Data_t *dataStruct = new Hazelcast_Data_t();
dataStruct->data = d;
return dataStruct;
}
...
Now this works, the client of my C library only sees typedef struct Hazelcast_Data_t Hazelcast_Data_t;. The problem is, that the aforementioned type cannot be allocated on the stack, like if I would like to provide an API like this:
// this is what I want to achieve, but Hazelcast_Data_t is an incomplete type
#include <include/c-wrapper/c-wrapper.h>
int main() {
char *str = "BLA";
Hazelcast_Data_t d;
stringToData(str, &d);
}
The compiler will throw an error that Hazelcast_Data_t is an incomplete type. I would still like to provide an API that allows to pass a stack-allocated reference of Hazelcast_Data_t to the serialization function, but because Hazelcast_Data_t has a pointer to the C++ class, this seems pretty much impossible. Having the option to pass a stack allocated reference however would greatly simplify the code for the client of my C library (no need to free the newed structure).
Is it somehow doable to redefine Hazelcast_Data_t type so that it can be used in C and still be allocated on the stack?

Answer 1

Most of the hacks you're thinking of for doing this invoke undefined behaviour, since C will not call the C++ constructor for the contained object when the struct is created, and not call the C++ destructor when the struct goes out of scope. To make it work you need the struct to contain a buffer of the right size and new into that buffer in an init function, and call the destructor on that buffer when done. This means the code looks like this (assuming that nothing throws - in which case you need to add exception handling and translation...)
struct wrapper {
char buffer[SIZE_OF_CXX_CLASS];
}
void wrapper_init() {
new (buffer) Wrapped();
}
void wrapper_destroy() {
((Wrapper*)buffer)->~Wrapper();
}
{
struct wrapper wrapped;
wrapper_init(&wrapped);
// ... use it ...
wrapper_destroy(&wrapped);
}
If you forget to call wrapper_init everything goes into undefined behvaiour land. If you forget to call wrapper_destroy I think you get UB too.
But since this forces your caller to call the init and destroy functions there's very little gain over using a pointer. I'd go so far as to claim that the use of a struct rather than a pointer suggests to API users that initialisation should be trivial, and destruction unnecessary. I.e. as an API user I'd expect to be able to do
{
struct wrapper wrapped = WRAPPER_INIT; //Trivial initialisaton macro
// .. use it ..
// No need to do anything it is a trivial object.
}
In the cases where this is not possible (like yours) I'd stick with the usual allocate it on the heap idiom
{
struct wrapper* wrapped = wrapper_create();
// ... use it ...
wrapper_destroy(wrapped);
}

Answer 2

You need to provide a definition of the struct in your header file such so that clients know how much space to allocate on the stack. But that becomes tricky when the underlying representation in a C++ class which can't be exposed by the extern "C".
The solution is a pointer to the C++ class rather than the actual class. As pointers are the same size this will work in the C client, even when it has no knowledge of C++.
Thus in the header
typedef struct Hazelcast_Data_t {
void *data
} Hazelcast_Data_t
And in the C++ file you can use static_cast to access the C++ class via this pointer.

Answer 3

Make a wrapper struct that simply contains an array large and aligned enough to contain your C++ type. Placement-new your C++ type in it.
You will probably have to build a small C++ executable that would generate a C header file with SIZEOF_HAZELCAST_T and ALIGNOF_HAZELCAST_T appropriately defined.