Type

(See also arithmetic types for the details on most built-in types and the list of type-related utilities that are provided by the C library)

Objects, functions, and expressions have a property called type, which determines the interpretation of the binary value stored in an object or evaluated by the expression.

object types: all types that aren't function types
character types: char, signed char, unsigned char
integer types: char, signed integer types, unsigned integer types, enumerated types
real types: integer types and real floating types
arithmetic types: integer types and floating types
scalar types: arithmetic types and pointer types
aggregate types: array types and structure types
derived declarator types: array types, function types, and pointer types

[edit] Compatible types

In a C program, the declarations referring to the same object or function in different translation units do not have to use the same type. They only have to use sufficiently similar types, formally known as compatible types. Same applies to function calls and lvalue accesses; argument types must be compatible with parameter types and lvalue expression type must be compatible with the object type that is accessed.

The types T and U are compatible, if

they are the same type (same name or aliases introduced by a typedef)
they are identically cvr-qualified versions of compatible unqualified types
they are pointer types and are pointing to compatible types
they are array types, and

their element types are compatible, and
if both have constant size, that size is the same. Note: arrays of unknown bound are compatible with any array of compatible element type. VLA is compatible with any array of compatible element type. (since C99)

they are both structure/union/enumeration types, and

(C99)if one is declared with a tag, the other must also be declared with the same tag.
if both are completed types, their members must correspond exactly in number, be declared with compatible types, and have matching names.
additionally, if they are enumerations, corresponding members must also have the same values.
additionally, if they are structures or unions,

Corresponding members must be declared in the same order (structures only)
Corresponding bit fields must have the same widths.

one is an enumerated type and the other is that enumeration's underlying type
they are function types, and

their return types are compatible
they both use parameter lists, the number of parameters (including the use of the ellipsis) is the same, the corresponding parameters have compatible types
one is an old-style (parameter-less) definition, the other has a parameter list, the parameter list does not use an ellipsis and each parameter is compatible (after function parameter type adjustment) with the corresponding old-style parameter after default argument promotions
one is an old-style (parameter-less) declaration, the other has a parameter list, the parameter list does not use an ellipsis, and all parameters (after function parameter type adjustment) are unaffected by default argument promotions

The type char is not compatible with signed char and not compatible with unsigned char.

If two declarations refer to the same object or function and do not use compatible types, the behavior of the program is undefined.

// Translation Unit 1
struct S {int a;};
extern struct S *x;  // compatible with TU2's x, but not with TU3's x
// Translation Unit 2
struct S;
extern struct S *x; // compatible with both x's
// Translation Unit 3
struct S {float a;};
extern struct S *x; // compatible with TU2's x, but not with TU1's x
 
// the behavior is undefined

// Translation Unit 1
#include <stdio.h>
struct s {int i;}; // compatible with TU3's s, but not TU2's
extern struct s x = {0}; // compatible with TU3's x
extern void f(void); // compatible with TU2's f
int main()
{
   f();
   return x.i;
}
// Translation Unit 2
struct s {float f;}; // compatible with TU4's s, but not TU1's s
extern struct s y = {3.14}; // compatible with TU4's y
void f() // compatible with TU1's f
{
   return;
}
// Translation Unit 3
struct s {int i;}; // compatible with TU1's s, but not TU2's s
extern struct s x; // compatible with TU1's x
// Translation Unit 4
struct s {float f;}; // compatible with TU2's s, but not TU1's s
extern struct s y; // compatible iwth TU2's y
 
// the behavior is well-defined: only multiple declarations
// of objects and functions must have compatible types, not the types themselves

Note: C++ has no concept of compatible types. A C program that declares two types that are compatible but not identical in different translation units is not a valid C++ program.

[edit] Composite types

[edit] Incomplete types

An incomplete type is an object type that lacks sufficient information to determine the size of the objects of that type. An incomplete type may be completed at some point in the translation unit.

The following types are incomplete:

the type void. This type cannot be completed.
array type of unknown size. It can be completed by a later declaration that specifies the size.
structure or union type of unknown content. It can be completed by a declaration of the same structure or union that defines its content later in the same scope.

[edit] Type names

A type may have to be named in context other than the declaration. In these situations, type name is used, which is, grammatically, exactly the same as a list of type-specifiers and type-qualifiers, followed by the declarator (see declarations) as would be used to declare a single object or function of this type, except that the identifier is omitted:

int n; // declaration of an int
sizeof(int); // use of type name
 
int *a[3]; // declaration of an array of 3 pointers to int
sizeof(int *[3]); // use of type name
 
int (*p)[3]; // declaration of a pointer to array of 3 int
sizeof(int (*)[3]); // use of type name
 
int (*a)[*] // declaration of pointer to VLA (in a function parameter)
sizeof(int (*)[*]) // use of type name (in a function parameter)
 
int *f(void); // declaration of function
sizeof(int *(void)); // use of type name
 
int (*p)(void); // declaration of pointer to function
sizeof(int (*)(void)); // use of type name
 
int (*const a[])(unsigned int, ...) = {0}; // array of pointers to functions
sizeof(int (*const [])(unsigned int, ...)); // use of type name

Except the redundant parentheses around the identifier are meaningful in a type-name and represent "function with no parameter specification":

int (n); // declares n of type int
sizeof(int ()); // uses type "function returning int"

Type names are used in the following situations:

cast
sizeof

compound literal	(since C99)
generic selection alignof alignas _Atomic (when used as a type specifier)	(since C11)

A type name may introduce a new type:

void* p = (void*)(struct X {int i;} *)0;
// type name "struct X {int i;}*" used in the cast expression
// introduces the new type "struct X"
struct X x = {1}; // struct X is now in scope

[edit] References

C11 standard (ISO/IEC 9899:2011):

6.2.5 Types (p: 39-43)

6.2.6 Representations of types (p: 44-46)

6.2.7 Compatible type and composite type (p: 47-48)

C99 standard (ISO/IEC 9899:1999):

6.2.5 Types (p: 33-37)

6.2.6 Representations of types (p: 37-40)

6.2.7 Compatible type and composite type (p: 40-41)

C89/C90 standard (ISO/IEC 9899:1990):

3.1.2.5 Types

3.1.2.6 Compatible type and composite type

[edit] See also

C++ documentation for Type

Language
headers
Type support
Dynamic memory management
Error handling
Program utilities
Variadic function support
Date and time utilities
Strings library
Algorithms
Numerics
Input/output support
Localization support
Thread support (C11)
Atomic operations (C11)
Technical Specifications

comments
ASCII
Translation phases
identifier
scope
lifetime
lookup and name spaces
type
arithmetic types
the main() function
memory model and data races