6.11 Incomplete Types

The ISO C standard introduced the term “incomplete type” to formalize a fundamental, yet misunderstood, portion of C, implicit from its beginnings. This section describes incomplete types, where they are permitted, and why they are useful.

6.11.1 Types

ISO separates C’s types into three distinct sets: function, object, and incomplete. Function types are obvious; object types cover everything else, except when the size of the object is not known. The Standard uses the term “object type” to specify that the designated object must have a known size, but note that incomplete types other than void also refer to an object.

There are only three variations of incomplete types: void, arrays of unspecified length, and structures and unions with unspecified content. The type void differs from the other two in that it is an incomplete type that cannot be completed, and it serves as a special function return and parameter type.

6.11.2 Completing Incomplete Types

An array type is completed by specifying the array size in a following declaration in the same scope that denotes the same object. When an array without a size is declared and initialized in the same declaration, the array has an incomplete type only between the end of its declarator and the end of its initializer.

An incomplete structure or union type is completed by specifying the content in a following declaration in the same scope for the same tag.

6.11.3 Declarations

Certain declarations can use incomplete types, but others require complete object types. Those declarations that require object types are array elements, members of structures or unions, and objects local to a function. All other declarations permit incomplete types. In particular, the following constructs are permitted:

• Pointers to incomplete types

• Functions returning incomplete types

• Incomplete function parameter types

• typedef names for incomplete types

The function return and parameter types are special. Except for void, an incomplete type used in such a manner must be completed by the time the function is defined or called. A return type of void specifies a function that returns no value, and a single parameter type of void specifies a function that accepts no arguments.

Because array and function parameter types are rewritten to be pointer types, a seemingly incomplete array parameter type is not actually incomplete. The typical declaration of main’s argv, namely, char *argv[], as an unspecified length array of character pointers, is rewritten to be a pointer to character pointers.

6.11.4 Expressions

Most expression operators require complete object types. The only three exceptions are the unary & operator, the first operand of the comma operator, and the second and third operands of the ?: operator. Most operators that accept pointer operands also permit pointers to incomplete types unless pointer arithmetic is required. The list includes the unary * operator.

For example, given the following expression, &*p is a valid subexpression that makes use of this situation.

void *p

6.11.5 Justification

Besides void, C has no other way to handle incomplete types: forward references to structures and unions. If two structures need pointers to each other, the only way to do so is with incomplete types:

struct a { struct b *bp; };
struct b { struct a *ap; };

All strongly typed programming languages that have some form of pointer and heterogeneous data types provide some method of handling this case.

6.11.6 Examples: Incomplete Types

Defining typedef names for incomplete structure and union types is frequently useful. If you have a complicated bunch of data structures that contain many pointers to each other, having a list of typedefs to the structures up front, possibly in a central header, can simplify the declarations.

typedef struct item_tag Item;
typedef union note_tag Note;
typedef struct list_tag List;
.  .  .
struct item_tag { .  .  .  };
.  .  .
struct list_tag {
    struct list_tag {
};

Moreover, for those structures and unions whose contents should not be available to the rest of the program, a header can declare the tag without the content. Other parts of the program can use pointers to the incomplete structure or union without any problems unless they attempt to use any of its members.

A frequently used incomplete type is an external array of unspecified length. Generally, you do not need to know the extent of an array to make use of its contents.