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;