Question about C/C++ struct memory layout compatibility

[Vincezo Ciaschini]

Supposing you have the following declaration in a header file:
-- head.h --

struct s {
int c;
char v;
#if defined(__cplus plus)
s();
s(double);
method1(int);
method2(float);
#endif
};

and then two sources,

-- cppsrc.cc --
#include "head.h"

extern "C" {
s *create(void)
{
s *res = new s(1.0);
res->method1(4);
return res;
}

-- csrc.c --
#include "head.h"

extern struct s *create(void);

int f()
{
struct s* val = create();
val->v = 'd';
}

Is this legal/portable?

Thanks in advance,
Vincenzo

[Shezan Baig]

Vincezo Ciaschini wrote:

Because they would not be in the same program. The cppsrc.cc would be
in a dynamic library that will be linked to the program containing
csrc.c. It is an effort to provide a C interface to a C++ library.

You probably need to make a clean-cut between the C++ interface and the
C interface, instead of attempting to mix them both in a single header
file. Use 2 header files:

head.h
------
normal C++ declaration here

head_c.h
--------
C declarations here

hth,
-shez-

[Andre Kostur]

Victor Bazarov <v.********@com Acast.net> wrote in news:8oYpe.8196 5
$N********@news read1.mlpsca01. us.to.verio.net :

Vincezo Ciaschini wrote:

Supposing you have the following declaration in a header file:
-- head.h --

struct s {
int c;
char v;
#if defined(__cplus plus)
s();
s(double);
method1(int);
method2(float);
#endif
};

and then two sources,

-- cppsrc.cc --
#include "head.h"

extern "C" {
s *create(void)
{
s *res = new s(1.0);
res->method1(4);
return res;
}

-- csrc.c --
#include "head.h"

extern struct s *create(void);

int f()
{
struct s* val = create();
val->v = 'd';
}

Is this legal/portable?
I have no definite answer to this question. I believe, though, that
it would be implementation-specific. However, regardless of what I
believe, I'd like to know *why* would you want to do something like
that. Why do you feel the need to have both C and C++ translation

units in the same program?

Arguably wouldn't that violate the One Definition Rule ?

[Rene Moehring]

On 9 Jun 2005 08:37:17 -0700, Rapscallion wrote:

Vincezo Ciaschini wrote:

Supposing you have the following declaration in a header file:
-- head.h -- ...

Is this legal/portable?

Maybe. But the classic way to provide a C interface for a C++ program
goes like this:

// somefile.h ----------------------
struct s; // declaration

extern "C" {
struct s *create(void);
void destroy (struct s* x);
void method1 (struct s* x, int);
// ...
}
// somefile.cpp --------------------
struct s {
s();
s(double);
method1(int);
method2(float);
private:
int c;
char v;
};

s *create(void)
{
struct s *res = new s(1.0);

This new could throw an exception. You should use the one that returns a
NULL pointer on error and handle that case.
res->method1(4);
return res;
}

void destroy (struct s* x) { ... }
void method1 (struct s* x, int) { ... }
// the C user ------------------------
int main() {
struct s* val = create();
method1 (s, 33);
destroy (s);
}

--
I'm not a racist. I hate everyone equally!

[Rapscallion]

Rene Moehring wrote:

On 9 Jun 2005 08:37:17 -0700, Rapscallion wrote:

....

s *create(void)
{
struct s *res = new s(1.0);

This new could throw an exception. You should use the one that returns a
NULL pointer on error and handle that case.

res->method1(4);
return res;
}

Good point. Not only new may throw but also 'res->method1(4)'. One
needs to surround function bodies with try {} catch (...){} blocks.