2.7 Compatible and Composite Types

Compatibility between types refers to the similarity of two types to each other. Type compatibility is important during type conversions and operations. All valid declarations in the same scope that refer to the same object or function must have compatible types. Two types are compatible if they fit any of the following categories:

• Two types are compatible if they are the same.

• Two qualified types (see Section 3.7) are compatible if they are identically qualified and the two types, unqualified, are compatible. The order of the qualifiers in the type declaration does not matter.

• The types short , signed short , short int , and signed short int are the same and are compatible.

• The types unsigned short and unsigned short int are the same and are compatible.

• The types int , signed , and signed int are the same and are compatible.

• The types unsigned and unsigned int are the same and are compatible.

• The types long , signed long , long int , signed long int are the same and are compatible.

• The types unsigned long and unsigned long int are the same and are compatible.

• Two array types are compatible if they are of the same size and contain elements of compatible types. If one array has an unknown size, it is compatible with all other array types having compatible element types.

• Two unions or structures are compatible if they are declared in different compilation units, share the same members in the same order, and whose members have the same widths (including bit fields).

• Two enumerations are compatible if all members have the same values. All enumerated types are compatible with other enumerated types. An enumerated type is also compatible with the signed int type.

• Two pointer types are compatible if they are identically qualified and point to objects of compatible types.

• A function type declared using the old-style declaration (such as int tree() ) is compatible with another function type if the return types are compatible.

• A function type declared using the new prototype- style declaration (such as int tree (int x) ) is compatible with another function type declared with a function prototype if:

  • The return types are compatible.

  • The parameters agree in number (including an ellipsis if one is used).

  • The parameter types are compatible. For each parameter declared with a qualified type, its type for compatibility comparison is the unqualified version of the declared type.

• The function type of a prototype-style function declaration is compatible with the function type of an old-style function declaration if the return types are compatible, and if the old-style declaration is not a definition. (Different styles of function declarations are discussed in Chapter 5.) Otherwise, the function type of a prototype- style function declaration is compatible with the function type of an old-style function definition if all of the following conditions are met:

  • The return types of the two functions are compatible.

  • The number of parameters agree.

  • The prototype-style function declaration does not contain an ellipsis as a parameter.

  • The promoted types of the old-style parameters are compatible with the prototype-style parameter types. In the following example, the functions tree and tree2 are compatible. tree and tree1 are not compatible, and tree1 and tree2 are not compatible.

    int tree (int);
    int tree1 (char);
    int tree2 (x)
       char x;   /* char promotes to int in old-style
                    function parameters, and so is
                    compatible with tree             */
       {
       ...
       };
    

The following types, which may appear to be compatible, are not:

• unsigned int and int types are not compatible.

• char , signed char , and unsigned char types are not compatible.

Composite Type

A composite type is constructed from two compatible types and is compatible with both of the two types. Composite types satisfy the following conditions:

• If one type is an array of known size, the composite type is an array of that size.

• If only one type is a function type with a prototype, the composite type is a function type with the parameter type list.

• If both types are functions types with prototypes, the type of each parameter in the composite parameter type list is the composite type of the corresponding parameters.

Consider the following file-scope declarations:

int f(int (*) (), double (*) [3]);
int f(int (*) (char *), double (*)[]);

They result in the following composite type for the function:

int f(int (*) (char *), double (*)[3]);

The previous composite type rules apply recursively to types derived from composite types.