c语言声明08

Posted 2021-04-25 周三石

整 a, *b=无效; // &l双引号; 整 &r双引号;是类型指定符,
                // &l双引号; a &r双引号;是声明器
                // &l双引号; *b &r双引号;是声明器而 无效 是初始化器
常 整 *f(空); // &l双引号; 整 &r双引号;是类型指定符
                    // &l双引号; 常 &r双引号;是类型限定符
                    // &l双引号; *f(空) &r双引号;是声明器
枚 颜色 {红, 绿色, 蓝} c; // &l双引号; 枚 颜色 {红, 绿色, 蓝} &r双引号;是类型指定符
                                 // &l双引号; c &r双引号;是声明器

构 C {
    整 成员; // &l双引号; 整 &r双引号;是类型指定符
                // &l双引号; 成员 &r双引号;是声明器
} 对象, *p对象 = &对象;
// &l双引号; 构 C { 整 成员; } &r双引号;是类型指定符
// 声明器&l双引号; 对象 &r双引号;定义 构 C 类型的对象
// 声明器&l双引号; *p对象 &r双引号;声明指向 构 C 的指针,
// 初始化器&l双引号; = &对象 &r双引号;提供该指针的初值
 
整 a = 1, *p = 无效, f(空), (*pf)(双精);
// 类型指定符是&l双引号; 整 &r双引号;
// 声明器&l双引号; a &r双引号;定义一个 整 类型对象
//   初始化器&l双引号;=1&r双引号;提供其初值
// 声明器&l双引号; *p &r双引号;定义一个指向 整 指针类型的对象
//   初始化器&l双引号; =无效 &r双引号;提供其初值
// 声明器&l双引号; f(空) &r双引号;声明接受 空 并返回 整 的函数
// 声明器&l双引号; (*pf)(双精) &r双引号;定义一个指向
//   接受 双精 并返回 整 的函数的指针类型对象
 
整 (*(*福)(双精))[3] = 无效;
// 类型指定符是&l双引号;整&r双引号;
// 1. 声明器&l双引号; (*(*福)(双精))[3] &r双引号;是数组声明器:
//    所声明类型是&l双引号; 3 个 整 的数组的 /嵌套声明器/ &r双引号;
// 2. 嵌套声明器是&l双引号; *(*福)(双精)) &r双引号;,是指针声明器
//    所声明类型是&l双引号; /嵌套声明器/ 指向 3 个 整 的数组的指针&r双引号;
// 3. 嵌套声明器是&l双引号; (*福)(双精) &r双引号;,是一个函数声明器
//    所声明类型是&l双引号; /嵌套声明器/ 接受 双精 并返回指向 3 个 整 的数组的指针的函数&r双引号;
// 4. 嵌套声明器是&l双引号; (*福) &r双引号;,是一个(有括号,函数声明器所要求)指针声明器.
//    所声明类型是&l双引号; /嵌套声明器/ 指向接受 双精 并返回指向 3 个 整 的数组的指针的函数的指针&r双引号;
// 5. 嵌套声明器是&l双引号; 福 &r双引号;,是一个标识符.
// 该声明引入一个标识符&l双引号; 福 &r双引号;,以指代一个对象,其类型为
// &l双引号;指向接受 双精 并返回指向 3 个 整 的数组的指针的函数的指针&r双引号;
// 初始化器&l双引号; = 无效 &r双引号;提供此指针的初值.
 
// 若在用于声明符形式的表达式使用&l双引号;福&r双引号;,则表达式类型将是整.
整 x = (*(*福)(1.2))[0];

整 福(双精); // 声明
整 福(双精 x){ 中 x; } // 定义

外 整 n; // 声明
整 n = 10; // 定义

构 X; // 声明
构 X { 整 n; }; // 定义

外 整 x;
整 x = 10; // 好
外 整 x; // 好
 
静 整 n;
静 整 n = 10; // 好
静 整 n; // 好

又 整 整型; 
又 整 整型; // 好

构 X;
构 X { 整 n; };
构 X;