Declarators

A brief summary of the syntax of declarators:

   declarator:
   	pointer[opt] direct-declarator

   direct-declarator:
   	identifier
   	( declarator )
   	direct-declarator [ constant-expression[opt] ]

   	direct-declarator ( parameter-type-list )
   	direct-declarator ( identifier-list[opt] )

   pointer:
   	* type-qualifier-list[opt]
   	* type-qualifier-list[opt] pointer

Pointer declarators

• Pointer to a type:

  char *p;
  

  p is a pointer to type char. p contains the address of a char object.

  Care should be taken when pointer declarations are qualified with const:

  const int *pci;
  

  declares a pointer to a const-qualified (``read-only'') int.

  int *const cpi;
  

  declares a pointer-to-int that is itself ``read-only.''

• Pointer to a pointer:

  char **t;
  

  t points to a character pointer.

• Pointer to a function:

  int (*f)();
  

  f is a pointer to a function that returns an int.

• Pointer to void:

  void *
  

  A pointer to void may be converted to or from a pointer to any object or incomplete type, without loss of information. This ``generic pointer'' behavior was previously carried out by char *; a pointer to void has the same representation and alignment requirements as a pointer to a character type.

Array declarators

• One-dimensional array:

  int ia[10];
  

  ia is an array of 10 integers.

• Two-dimensional array:

  char d[4][10];
  

  d is an array of 4 arrays of 10 characters each.

• Array of pointers:

  char *p[7];
  

  p is an array of seven character pointers.

Function declarators

• A function declaration includes the return type of the function, the function identifier, and an optional list of parameters.

• Function prototype declarations include declarations of parameters in the parameter list.

• If the function takes no arguments, the keyword void may be substituted for the parameter list in a prototype.

• A parameter type list may end with an ellipsis ``, . . . '' to indicate that the function may take more arguments than the number described. The comma is necessary only if it is preceded by an argument.

• The parameter list may be omitted, which indicates that no parameter information is being provided.

• void srand(unsigned int seed);

  The function srand returns nothing; it has a single parameter which is an unsigned int. The name seed goes out of scope at the ) and as such serves solely as documentation.

• int rand(void);

  The function rand returns an int; it has no parameters.

• int strcmp(const char *, const char *);

  The function strcmp returns an int; it has two parameters, both of which are pointers to character strings that strcmp does not change.

• void (*signal(int, void (*)(int)))(int);

  The function signal returns a pointer to a function that itself returns nothing and has an int parameter; the function signal has two parameters, the first of which has type int and the second has the same type as signal returns.

• int fprintf(FILE *stream, const char *format, . . .);

  The function fprintf returns an int; FILE is a typedef name declared in stdio.h; format is a const qualified character pointer; note the use of ellipsis ( . . . ) to indicate an unknown number of arguments.