Forward "Typedefing" a struct - c

Question

I've a slight problem with my include files and I've made a simplified mockup of my problem.
Say I'm compiling some source that requires a header file named
header.h
Which has in it:
#ifndef HEADER_INCLUDED
#define HEADER_INCLUDED
#include element.h
typedef struct {
Element *list;
} Thing;
#endif
Then I have another header file defining that Element and also requiring header.h.
element.h
#ifndef ELEMENT_INCLUDED
#define ELEMENT_INCLUDED
typedef struct Element;
#include header.h
void * func(Thing *myThing);
#endif
I then run into a problem because element.h can't know what the Thing type is; we haven't reached that definition in header.h because we needed to include element.h.
I thought I could maybe solve my problem for "forward typedefing" a Thing type in element.h and right before the void * func prototype like
typedef struct thing Thing;
Then this just creates another problem and the compiler complains that there are conflicting types for Thing.
How do I get out of this mess?

Answer 1

Your main problem is that there is a cyclic dependency between the 2, yet you're using guard macros. The files are included almost as if by copy-paste - one of the files has to be included before the other, so you cannot have such cyclic dependency. Rethink your structure.
Declare/define the basic data type in 1 place, then the derived/composite data types using that, and finally the functions that take those types as arguments/return values.
Also, typedef struct Element; is invalid typedef.

Answer 2

Simplest way to solve your problem is to isolate your struct definition in its own header, protected by #ifndef/#define as usual. If you don't want a header file for this single struct, define the struct twice and protect its definition by another #ifndef/#define this way:
#ifndef __BOOLEAN_ENUM__
#define __BOOLEAN_ENUM__
enum boolean
{
false = 0,
true = 1
};
#endif

Answer 3

header.h should not include element.h. Otherwise you have circular dependency.
The code you posted has a large number of errors. (In future, post real code that you tried to compile, instead of making stuff up as you go in the edit box). Here is an example, where I have omitted the header guards for brevity:
// header.h
struct Element; // actually not necessary, but may help with readability
typedef struct
{
struct Element *ptr;
} Thing;
and
// element.h
#include "header.h"
struct Element
{
int x;
};
typedef struct Element Element; // optional
void * func(Thing *myThing);
It would be possible to also place typedef struct Element Element; in header.h and use Element *ptr inside the definition of Thing, it is a matter of taste as to which way you prefer. Some people disapprove of using typedef with structs at all in C, however I like it as it means that a typo leads to an immediate compilation error, instead of silently creating a new type.
If you also want element.h to not depend on header.h, you can use the same technique with Thing. You need to give it a struct tag , like how struct Element has.

Answer 4

Just step back from the C code and thing of the overall program design.
It is clear that the "Thing" struct must depend on the "Element" struct in element.h. However, it doesn't make any sense to use functions that depend on "Thing" from inside the element header. It rather makes most sense that functions using "Thing" should be inside the "Thing" header.
If you look at it with an object-oriented approach, which you should no matter programming language, then Element is a class, Thing is a class. The function could either be a member function of Thing, or it could be a non-related function using that class.
What you would do in object-oriented C, is to declare both "Element" and "Thing" as incomplete types in their respective headers. The type definition is hidden from the caller, and only present in those header's respective C files, called element.c and thing.c. All member functions dealing with the respective classes will be declared in the headers and defined in the C files. (This design is also sometimes called opaque type or opaque pointers.)
Functions using either class will then simply include the needed header.