Declarations are constructs in a program that state that a name identifies an object, type or function, and describe that entity. Every declaration has a scope, which indicates in which lexical portion of a source file the declared name has its declared meaning.

translation-unit

external-declaration

translation-unit external-declaration

external-declaration

function-definition

declaration

declaration

declaration-specifiers init-declarator-listopt

static_assert-declaration

since C11

declaration-specifiers

storage-class-specifier declaration-specifiersopt

type-specifier declaration-specifiersopt

type-qualifier declaration-specifiersopt

function-specifier declaration-specifiersopt

alignment-specifier declaration-specifiersopt

storage-class-specifier

typedef

extern

static

_Thread_local

auto

register

init-declarator-list

init-declarator

init-declarator-list , init-declarator

init-declarator

declarator

declarator = initializer

declarator

pointeropt direct-declarator

direct-declarator

identifier

( declarator )

direct-declarator [ type-qualifier-listopt assignment-expressionopt ]

Arrays

direct-declarator [ static type-qualifier-listopt assignment-expression ]

Arrays

direct-declarator [ type-qualifier-list static assignment-expression ]

Arrays

direct-declarator [ type-qualifier-listopt * ]

Arrays

direct-declarator ( parameter-type-list )

direct-declarator ( identifier-listopt )

The pre-standard way

initializer

assignment-expression

{ initializer-list }

{ initializer-list , }

since C99

initializer-list

designationopt initializer

initializer-list , designationopt initializer

designation

designator-list =

designator-list

designator

designator-list designator

designator

[ constant-expression ]

Arrays

. identifier

A single name does not always mean the same thing in all contexts. The lexical context in which a name has a given meaning is called its scope.

Variables, types and functions declared inside a block statement have block scope; the declared name only identifies that entity from a point just after the declaration until the end of the block. Other blocks within the block could declare the same name to identify a different entity, hiding the outer meaning until the end of the inner block.

Declaration scope is similar, and applies to names declared within function declarations. For example, this declaration (which is also a function definition) declares two parameters ap and bp, whose scopes extend to the end of the definition:

void swap(int *ap, int *bp)
{
  int tmp = *ap;
  *ap = *bp;
  *bp = tmp;
}

The declaration scopes of ap and bp are almost the same as the block scope of tmp, starting only a little earlier, and ending at the same place. This is of no consequence in that example, but it is relevant when declaring a function taking a multidimensional array as one argument, and a dimension of that array as another:

double sum(int h, int w, double arr[h][w]);

The declarations of h and w must come before arr so that it falls within their scopes.

Declaration scope is also important when structure types, union types and enumeration types appear in function declarations. For example, in this declaration:

void foo(struct bar *bp);

…the name struct bar is only in scope until the end of the prototype. Any references to struct bar after that point will be considered to refer to a different type. This problem does not occur if struct bar was already declared independently before the prototype, however.

Lastly, there is file scope, which lasts from the point of declaration to the end of the translation unit. Names of objects, types and functions with file scope can be hidden locally by identical names declared with declaration or block scope. All macros effectively have file scope, as they are resolved by the preprocessor which has no notion of scope. For the same reason, they also cannot be hidden by inner scopes.