Pure C: when using typdef void StructName in header file, the header file can't be included into the.c file

Question

I have a header file that looks like this:

typedef void Square;

extern Square*  Square_Init       (int width, int height);
extern void     Square_Delete     (Cube* cube);
extern int      Square_GetWidth   (Cube* cube);
extern int      Square_GetHeight  (Cube* cube);

and a.c file, looking something like this:

/* #include "square.h" */ /* compiler gets mad for redefining Square */

typedef struct {
    unsigned int width;
    unsigned int height;
} Square;

Square* Square_Init (int width, int height) {. . .}

void Square_Delete (Cube* cube) {. . .}

int Square_GetWidth (Cube* cube)  {. . .}

int Square_GetHeight (Cube* cube) {. . .}

When I finally include my header file in let's say main.c, all the functions work well. It is just a bit odd for me, that I can't include the square.h file into the square.c file. Can it be done somehow?

Answer 1

What you seem to want to do is an opaque type. But void * is not a type compatible with struct pointers, so you cannot use them interchangeably, and most definitely cannot use void interchangeably with a structure type.

---

The correct way is to use a tagged structure without definition in the header, for example:

typedef struct square Square;

and if you include the header in your .c file, you just need to add:

struct square {
    unsigned int width;
    unsigned int height;
};

Answer 2

This code...

 typedef void Square;

... is ok in itself. It declares the identifier Square to be an alias for the type void .

This code...

 typedef struct { unsigned int width; unsigned int height; } Square;

... is also ok by itself. It declares the identifier Square to be an alias for a tagless structure type with members { unsigned int width; unsigned int height; } { unsigned int width; unsigned int height; } { unsigned int width; unsigned int height; } .

But the two are not at all compatible with each other. Therefore, if you include the header into a C source file that includes the latter typedef then you have two conflicting declarations of the same typedef identifier. Not only is the resulting behavior undefined, but this is one of the cases that a conforming C compiler is required to diagnose.

Furthermore, although this declaration...

 extern Square* Square_Init (int width, int height);

... is valid with either typedef , it has slightly different meaning depending on which is in scope where it appears. As a result, code that calls the function with the declaration from the header in scope has undefined behavior (but this is not a case that the compiler is required to diagnose).

Do not be confused by the fact that C provides automatic conversions back and forth between void * and other object pointer types. That's a matter of values being somewhat interchangeable, but it does not mean that the types are interchangeable.

Nevertheless, inasmuch as it is common in modern C implementations for pointers to different kinds of objects all to have the same size and representation, it is not so surprising that the undefined behavior arising from calling the function with a mismatched declaration in scope happens to manifest (so far) as exactly the behavior you expected. But that doesn't mean you should do this.

The easiest thing to do would be to move the latter typedef to the header, so that everyone agrees completely about what a Square is. However, if you want to hide the definition of Square while allowing other code to use pointers to instances of that type and maintaining substantial type safety, then the header can forward declare Square as a structure type without (ever) defining the members, as Antti demonstrates in his answer . This makes Square an "opaque type" from the perspective of code that has only the declaration from the header.