声明

int a, *b=NULL; // “ int ”是类型指定符，
                // “ a ”是声明器
                // “ *b ”是声明器而 NULL 是初始化器
const int *f(void); // “ int ”是类型指定符
                    // “ const ”是类型限定符
                    // “ *f(void) ”是声明器
enum COLOR {RED, GREEN, BLUE} c; // “ enum COLOR {RED, GREEN, BLUE} ”是类型指定符
                                 // “ c ”是声明器

struct C {
    int member; // “ int ”是类型指定符
                // “ member ”是声明器
} obj, *pObj = &obj;
// “ struct C { int member; } ”是类型指定符
// 声明器“ obj ”定义 struct C 类型的对象
// 声明器“ *pObj ”声明指向 struct C 的指针，
// 初始化器“ = &obj ”提供该指针的初值
 
int a = 1, *p = NULL, f(void), (*pf)(double);
// 类型指定符是“ int ”
// 声明器“ a ”定义一个 int 类型对象
//   初始化器“=1”提供其初值
// 声明器“ *p ”定义一个指向 int 指针类型的对象
//   初始化器“ =NULL ”提供其初值
// 声明器“ f(void) ”声明接受 void 并返回 int 的函数
// 声明器“ (*pf)(double) ”定义一个指向
//   接受 double 并返回 int 的函数的指针类型对象
 
int (*(*foo)(double))[3] = NULL;
// 类型指定符是“int”
// 1. 声明器“ (*(*foo)(double))[3] ”是数组声明器：
//    所声明类型是“ 3 个 int 的数组的 /嵌套声明器/ ”
// 2. 嵌套声明器是“ *(*foo)(double)) ”，是指针声明器
//    所声明类型是“ /嵌套声明器/ 指向 3 个 int 的数组的指针”
// 3. 嵌套声明器是“ (*foo)(double) ”，是一个函数声明器
//    所声明类型是“ /嵌套声明器/ 接受 double 并返回指向 3 个 int 的数组的指针的函数”
// 4. 嵌套声明器是“ (*foo) ”，是一个（有括号，函数声明器所要求）指针声明器。
//    所声明类型是“ /嵌套声明器/ 指向接受 double 并返回指向 3 个 int 的数组的指针的函数的指针”
// 5. 嵌套声明器是“ foo ”，是一个标识符。
// 该声明引入一个标识符“ foo ”，以指代一个对象，其类型为
// “指向接受 double 并返回指向 3 个 int 的数组的指针的函数的指针”
// 初始化器“ = NULL ”提供此指针的初值。
 
// 若在用于声明符形式的表达式使用“foo”，则表达式类型将是int。
int x = (*(*foo)(1.2))[0];

int foo(double); // 声明
int foo(double x){ return x; } // 定义

extern int n; // 声明
int n = 10; // 定义

struct X; // 声明
struct X { int n; }; // 定义

extern int x;
int x = 10; // OK
extern int x; // OK
 
static int n;
static int n = 10; // OK
static int n; // OK

typedef int int_t; 
typedef int int_t; // OK

struct X;
struct X { int n; };
struct X;