By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
448,538 Members | 875 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 448,538 IT Pros & Developers. It's quick & easy.

struct declaration query

P: n/a
I'm trying to figure out some code that uses structures, structures, and
more structures...

It's a bit of rat's nest, and I'm having some trouble sorting it all out.

The authors use a lot of the following 'declarations' in the various .h
files:

struct document;
struct document_view;
struct link;
struct session;
struct term_event;
struct terminal;
struct uri;
struct conv_table;

These aren't being used as a part of another structure; they're just
standalone declarations? statements?

I can't quite picture what these do.

What exactly would be the effect of those empty declarations?

Maybe that will help me trace the code....

--Yan
Apr 26 '07 #1
Share this Question
Share on Google+
6 Replies


P: n/a
In article <13*************@corp.supernews.com>
CptDondo <ya*@NsOeSiPnAeMr.comwrites:
>I'm trying to figure out some code that uses structures, structures, and
more structures...

It's a bit of rat's nest, and I'm having some trouble sorting it all out.

The authors use a lot of the following 'declarations' in the various .h
files:

struct document;
struct document_view;
struct link;
struct session;
struct term_event;
struct terminal;
struct uri;
struct conv_table;

These aren't being used as a part of another structure; they're just
standalone declarations? statements?
They are incomplete types. Usually, the reason for putting those
in is that something in the file declares a pointer to one of them:

struct foo;
void useFoo(foo *fooPtr);

The compiler doesn't need the detail of the struct to deal with a
pointer. Any file that uses the fields inside these structs will
need a complete type defined.

Some libraries use this for encapsulation -- they give you a pointer
that you send back in every call, but no one outside the library
looks inside the struct.
>I can't quite picture what these do.

What exactly would be the effect of those empty declarations?
They tell you, "These types exist and you don't need to know what
is inside them."

--
Drew Lawson | "But the senator, while insisting he was not
dr**@furrfu.com | intoxicated, could not explain his nudity."
Apr 26 '07 #2

P: n/a
CptDondo wrote:
I'm trying to figure out some code that uses structures, structures, and
more structures...

It's a bit of rat's nest, and I'm having some trouble sorting it all out.

The authors use a lot of the following 'declarations' in the various .h
files:

struct document;
struct document_view;
struct link;
struct session;
struct term_event;
struct terminal;
struct uri;
struct conv_table;

These aren't being used as a part of another structure; they're just
standalone declarations? statements?
They are forward declarations, they let the compiler know that these
types exit. You will probably see use of pointers to these as function
parameters or structure members.

--
Ian Collins.
Apr 26 '07 #3

P: n/a
Drew Lawson wrote:
>I can't quite picture what these do.

What exactly would be the effect of those empty declarations?

They tell you, "These types exist and you don't need to know what
is inside them."
OK, thanks. That explains a lot.

The code uses a lot of structures with pointers to other structures, and
macros that define yet more pointers....

The parts I've figured out make sense... But it sure is complicated. :-)

--Yan
Apr 26 '07 #4

P: n/a
On Apr 27, 7:38 am, d...@furrfu.com (Drew Lawson) wrote:
CptDondo <y...@NsOeSiPnAeMr.comwrites:
The authors use a lot of the following 'declarations' in the various .h
files:
struct document;
struct document_view;

They are incomplete types. Usually, the reason for putting those
in is that something in the file declares a pointer to one of them:

struct foo;
void useFoo(foo *fooPtr);
Should read:
void useFoo( struct foo *fooPtr );

If you write this code without the forward declaration, then
'struct foo' gets declared with "prototype scope", meaning
that any subsequent file-scope "struct foo" is actually a
different struct. (Don't ask me why).

Apr 26 '07 #5

P: n/a
In article <11**********************@u32g2000prd.googlegroups .com>
Old Wolf <ol*****@inspire.net.nzwrites:
>On Apr 27, 7:38 am, d...@furrfu.com (Drew Lawson) wrote:
> CptDondo <y...@NsOeSiPnAeMr.comwrites:
>The authors use a lot of the following 'declarations' in the various .h
files:
>struct document;
struct document_view;

They are incomplete types. Usually, the reason for putting those
in is that something in the file declares a pointer to one of them:

struct foo;
void useFoo(foo *fooPtr);

Should read:
void useFoo( struct foo *fooPtr );
Sorry about that.
I'm lazy and hate typing 'struct' all the time, so I have been doing
typedefs for all my structs forever. That seems to have made my
posting a bit sloppy.
>If you write this code without the forward declaration, then
'struct foo' gets declared with "prototype scope", meaning
that any subsequent file-scope "struct foo" is actually a
different struct. (Don't ask me why).
That's a new one. I'm not sure I should try to understand that on
a Friday afternoon.
--
Drew Lawson For it's not the fall, but landing,
dr**@furrfu.com That will alter your social standing
Apr 27 '07 #6

P: n/a
Drew Lawson wrote:
>
In article <11**********************@u32g2000prd.googlegroups .com>
Old Wolf <ol*****@inspire.net.nzwrites:
[...]
If you write this code without the forward declaration, then
'struct foo' gets declared with "prototype scope", meaning
that any subsequent file-scope "struct foo" is actually a
different struct. (Don't ask me why).

That's a new one. I'm not sure I should try to understand that on
a Friday afternoon.
In that case, try wrapping your head around this error message:

usenet.c(14) : warning C4133: 'function' : incompatible types -
from 'struct foobar *' to 'struct foobar *'

Here's the source:

==========
int foo(struct foobar *ptfoo)
{
return 42;
}

struct foobar
{
int a;
int b;
};

int bar(struct foobar *ptbar)
{
return foo(ptbar);
}
==========

When compiling in ANSI mode, the "struct foobar *" type of the
parameter to foo() is not the same "struct foobar *" type of the
parameter to bar().

--
+-------------------------+--------------------+-----------------------+
| Kenneth J. Brody | www.hvcomputer.com | #include |
| kenbrody/at\spamcop.net | www.fptech.com | <std_disclaimer.h|
+-------------------------+--------------------+-----------------------+
Don't e-mail me at: <mailto:Th*************@gmail.com>

Apr 27 '07 #7

This discussion thread is closed

Replies have been disabled for this discussion.