C 嵌套结构的问题。 错误：无效使用不完整的 typedef

Question

For the sake of simplicity I'm going to recreate the actual situation with dummy structures. I have this structure (not my code, I can't edit it):

// private_header_a.h
struct A_s{
 int a1;
};
// header_a.h
typedef struct A_s A_t;

Then in one of my headers I extended it this way:

// my_header.h
typedef struct B_s{
 A_t* a_f;
 int b1;
} B_t;

Now, in my function, I have:

B_t* b;
// Initialization and some other code
b->b1 = 4; // Just an example and compiler does not give any error
// Some other code
b->a_f->a1;

This last line of code makes the compiler throw this error:

error: invalid use of incomplete typedef ‘A_t’ {aka ‘struct A_s’}

Where is the error? EDIT: the piece of code that triggers the compiler has header_a.h and my_header.h included. private_header_a.h cannot be included directly as not installed (I should copy-paste it, but frankly I would like to avoid to do that)

Answer 1

Here's two fundamental rules:

1. Each c file is compiled separately
2. When you #include a file, think of it as directly replacing the #include line with the contents of the file being included.

Therefore, you are compiling a piece of source code that looks like this:

struct A_s {
 int a1;
};

typedef struct B_s {
 A_t* a_f;
 int b1;
} B_t;

void foo() {
  B_t* b;
}

This code doesn't know what A_t is. You've never defined that in the code that's visible to the compiler.

A trivial way to fix this is to replace A_t with struct A_s .

Answer 2

The compiler error is probably intentional - the library's designers don't want you using A_t directly in that sort of way.

When a struct is only declared in a library's public header file, and only defined in the library's private implementation files, that means you're not supposed to know or care about its members or even size. So looking up that the struct has a member named a1 and writing b->af->a1 is not the intended use. This arrangement is called an "opaque handle". A few of its benefits are that the library keeps your application code from initializing or changing members in ways that don't make sense, and a future version of the library can change the names, numbers, and meanings of the members without breaking your application code.

(Also, how did you get a valid pointer for b->af without doing malloc(sizeof(A_t)) or similar? That sizeof would also cause a compiler error about the incomplete struct type.)

When a library uses an opaque handle, since you can't create any such objects yourself, it will typically provide functions that create the objects for you. Look for public functions in the library with names including init , create , open , etc. which return an A_t* pointer, and read their documentation. Usually there will also be a corresponding destroy , cleanup , close , etc. function which the program should call later when the library object is no longer needed. (In the case of some very simple handles, the function which creates the object might say instead you should just pass the pointer to free . But only do this if the documentation says to!)