forward declarations and incomplete types

[fmassei]

Hello,
I'm have a question about forward structure declarations and
incomplete types. The complete structure of my file is pretty complex,
but just as an example the code below will explain the problem:

struct b;
struct a {
struct b m;
};
struct b {
struct a m;
};

This code won't compile: my compiler (gcc) says that a.m "has
incomplete type". Changing the members' types to structure pointers
works, but it will be nicer if I could do this as if the two
definitions were not "cross-defined".
Is there a way for doing this?

[gw7rib]

On 19 Jul, 12:07, [e-mail] wrote:

Hello,
I'm have a question about forward structure declarations and
incomplete types. The complete structure of my file is pretty complex,
but just as an example the code below will explain the problem:

struct b;
struct a {
* * struct b m;};

struct b {
* * struct a m;

};

This code won't compile: my compiler (gcc) says that a.m "has
incomplete type". Changing the members' types to structure pointers
works, but it will be nicer if I could do this as if the two
definitions were not "cross-defined".
Is there a way for doing this?

I thought this was a FAQ, but I can't actually find it...

Your problem is that you want a to contain a b, and b to contain an a.
In fact, the way you have written it, the two structs look identical,
and there don't seem to be any actual members there that you can use.
But if there were, then you would be wanting each struct to be bigger
than the other. Obviously this is impossible.

You probably want at least one of the structs (probably both) to
contain a pointer to a struct of the other sort. If this does not seem
right, feel free to come back with more details.

Hope that helps.
Paul.

[fmassei]

On 19 Lug, 13:46, [e-mail] wrote:

On 19 Jul, 12:07, [e-mail] wrote:

Hello,
I'm have a question about forward structure declarations and
incomplete types. The complete structure of my file is pretty complex,
but just as an example the code below will explain the problem:

struct b;
struct a {
struct b m;};

struct b {
struct a m;

};

This code won't compile: my compiler (gcc) says that a.m "has
incomplete type". Changing the members' types to structure pointers
works, but it will be nicer if I could do this as if the two
definitions were not "cross-defined".
Is there a way for doing this?

I thought this was a FAQ, but I can't actually find it...

Your problem is that you want a to contain a b, and b to contain an a.
In fact, the way you have written it, the two structs look identical,
and there don't seem to be any actual members there that you can use.
But if there were, then you would be wanting each struct to be bigger
than the other. Obviously this is impossible.

You probably want at least one of the structs (probably both) to
contain a pointer to a struct of the other sort. If this does not seem
right, feel free to come back with more details.

Hope that helps.
Paul.

Ok, one problem is actually caused by my stupidity :) Of course I
can't have them the way I wrote. At this point the "incomplete type"
problem remains but it's easy to solve moving the code (I added some
other members just to make it more realistic).

struct b;
struct a {
int i;
struct b m;
};
struct b {
int i, j;
struct a *m;
};

This will continue not to work. But I don't think there's a way to get
around it without moving things around, isn't it?

[rahul]

On Jul 19, 5:00*pm, [e-mail] wrote:

struct b;
struct a {
* * int i;
* * struct b m;};

No work arounds for this are possible; you need to have a pointer to
the incomplete type. The definition reserves space and in this case,
it can't reserve memory as the compiler is not aware about the amount
of space.

>
struct b {
* * int i, j;
* * struct a *m;

Need not have a pointer(until and unless you really need it to be a
pointer; i.e not required by the compiler)

[gw7rib]

On 19 Jul, 13:00, [e-mail] wrote:

struct b;
struct a {
* * int i;
* * struct b m;};

struct b {
* * int i, j;
* * struct a *m;

};

This will continue not to work. But I don't think there's a way to get
around it without moving things around, isn't it?

No, that won't work, because if you're going to include a whole b as
part of a, it needs to know how big b is. So you need to tell it that
first.

But your code should work if you move things around, as follows:

struct a;

struct b {
int i, j;
struct a *m;
};

// no problem here, we just want a pointer to a

struct a {
int i;
struct b m;};

// no problem here, we now know how big a b is.

Paul.

[Martin Ambuhl]

fm*****@gmail.com wrote:

Hello,
I'm have a question about forward structure declarations and
incomplete types. The complete structure of my file is pretty complex,
but just as an example the code below will explain the problem:

struct b;
struct a {
struct b m;
};
struct b {
struct a m;
};

This involves infinitely large memory for even a single instance of
either struct. Be glad your compiler rejects it.