Declarators

Declarators include:

• Pointer declarators

• Array declarators

• Function declarators

   declarator:
   	pointeropt direct-declarator
   direct-declarator:
   	identifier
   	(declarator)
   	direct-declarator [constant-expressionopt]
   	direct-declarator (parameter-type-list)
   	direct-declarator (identifier-listopt)
   pointer:
   	* type-qualifier-listopt
   	* type-qualifier-listopt 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

note the use of ellipsis ( . . . ) to indicate an unknown number of arguments.