i would complement your own answer by saying that every identifier has to be defined somewhere before being used. in fact, the compiler needs to know the size of a type before being able to use that type in a declaration (variable declaration, function parameter list, etc.). this is because the size matters when generating the output code.
(warning: the remaining is quite advanced C programming. )
to go further, you need to know that pointers have a fixed size which is intrinsic to the compiler: the size of a pointer depends on the processor architecture, thus it is well-known (this also applies to primary types like int, double, or such). thus, in a header file you can write:
struct something;
this declares a structure type named something whose content is unknown. then, in the same header, you can use a pointer to this structure, although the content of the structure is still unknown. the content will be filled later.
so to summarize:
device.h:
struct DevList; // now the name exists, but we still don't know what it contains
void ListDevices( struct DevList *buffer ); // we use the name.
device.c:
#include "device.h"
[...]
struct DevList
{
int count;
Deviceinfo devs[128];
};
void ListDevices( struct DevList *buffer )
{
[...]
}
this is perfectly valid C, and allows the use of "opaque" types: the type DevList exists anywhere outside device.c, but its content is unknown. so anyone can use a pointer to DevList, although its content is unknown, since the size of a pointer is known. of course, since the content of DevList is only known inside device.c, you can manipulate the content of a DevList only inside functions declared in device.c. this way of hiding the content of a structure is called data abstraction.
another use of this is for what is called a "forward declaration", which is used to declare types that mutually refers to each other, like the node of a linked list for example.
