在C结构中定义C ++函数

Question

After reading

1. possible to define a function inside a C structure? [duplicate]
2. Define functions in structs

I wonder if the following workaround would work and what can be its deepest implications at compiler-level.

// foo.h
typedef struct foo
{
    int i;
#ifdef __cplusplus
    foo(int _i) : i(_i) {};
#endif
} foo;

// bar.c
#include "foo.h"
foo bar;
bar.i = 1;

// bar.cpp
#include "foo.h"
foo bar(2);

In my view is a great trick to leverage "struct polymorphism", being able to keep portability with C legacy code, but I have the feeling that in some way I'm now working with two different types.

Answer 1

Looking at this struct definition from your question:

typedef struct foo
{
    int i;
#ifdef __cplusplus
    foo(int _i) : i(_i) {};
#endif
} foo;

It is likely to result in the same memory representation when compiled with a C and a C++ compiler targeting the same platform. But you should never rely on this. The type the C++ compiler sees has one member more than the type the C compiler sees, so they are fundamentally different types. Therefore, treating them as the same is undefined behavior . If this works as you expect, it's by pure luck and might break at any time.

As already commented, introducing a virtual function is almost guaranteed to break it, as the C++ compiler will need to store the vtable somewhere in the struct . But even without that, there are many other ways in which it could break, for example because the compilers will add different padding. Just don't do this.

What you could do instead is use a plain C struct and add a wrapper class in C++ when you need it.

Answer 2

The two are distinct types. Compiling as C results in a different type than compiling as C++. Use both in the same program at the same time (ie linking the C and C++ objects together into one exectuable) and the result will be undefined behaviour, due to violation on the one-definition rule in C++.

This is not the way to keep portability between C and C++. The behaviour is undefined, so you might get lucky and find it works as you intend. But, equally, the behaviour is undefined, so it may not work.

Answer 3

If you want to ensure compatibility with a C library, this isn't the way.

You want to define a type that is-a foo and can be passed to the library functions. So do just that, inherit:

class shiny_foo : foo {
  // Member functions and anything that changes the object layout.
};

extern "C" void c_bar_func(foo *);

void cxx_bar_func(shiny_foo& obj) {
  // do stuff
  c_bar_func(&obj); // obj *is-a* foo as well, remember
}