c语言04

Posted 2021-04-25 周三石

浮 fa[11], *麦共协[17]; // fa 是 11 个 浮 组成的数组
                        // 麦共协 是 17 个指向 浮 的指针组成的数组

整 n[10]; // 整数常量是常量表达式
符 o[的大小(双精)]; // 的大小 是常量表达式
枚 { 最大串=100 };
整 n[最大串]; // 枚举常量是常量表达式

整 a[5] = {1,2,3}; // 声明 整[5] 初始化为 1,2,3,0,0
符 串[] = "abc"; // 声明 符[4] 初始化为 'a','b','c','\0'

空 浮加(双精 a[静 10], 常 双精 b[静 10])
{ 
    对 (整 i = 0; i < 10; i++) {
        如 (a[i] < 0.0) 中;
        a[i] += b[i];
    }
}
// 对 浮加 的调用进行一个编译时边界检查
// 并且允许诸如预读取 10 个 双精 的优化
整 主(空)
{
    双精 a[10] = {0}, b[20] = {0};
    浮加(a, b); // 好
    双精 x[5] = {0};
    浮加(x, b); // 错误:数组参数太小
}

整 f(常 整 a[20])
{
 // 此函数中, a 拥有类型 常 整* (指向 常 整 的指针)
}
整 g(常 整 a[常 20])
{
 // 此函数中, a 拥有类型 常 整* 常 (指向 常 整 的 常 指针)
}

空 浮加(双精 a[静 限制 10],
          常 双精 b[静 限制 10])
{
    对 (整 i = 0; i < 10; i++) { // 循环可被打开或重排
        如 (a[i] < 0.0) 断;
        a[i] += b[i];
    }
}

{
   整 n = 1;
标签:;
   整 a[n]; // 重分配 10 次,每次拥有不同大小
   打印格式("这 数组 有 %zu 元素\n", 的大小 a / 的大小 *a);
   如 (n++ < 10) 至 标签; // 离开作用域的 变长数组 结束其生存期
}

空 福(大小型 x, 整 a[*]);
空 福(大小型 x, 整 a[x]) 
{
    打印格式("%zu\n", 的大小 a); // 大小同的大小(整*)
}

外 整 n;
整 A[n];            // 错误:文件作用域 变长数组
外 整 (*p2)[n]; // 错误:文件作用域 虚机
整 B[100];          // 好:文件作用域的已知常量大小数组
空 f变长数组(整 m, 整 C[m][m]); // 好:原型作用域 变长数组

空 f变长数组(整 m, 整 C[m][m]) // 好 :块作用域/自动存储期到 变长数组 的指针
{
    又 整 变长数组[m][m]; // 好 :块作用域 变长数组
    整 D[m];              // 好 :块作用域/自动存储期 变长数组
//  静 整 E[m]; // 错误:静态存储期 变长数组
//  外 整 F[m]; // 错误:拥有链接的 变长数组
    整 (*s)[m];     // 好:块作用域/自动存储期 虚机
//  外 整 (*r)[m]; // 错误:拥有链接的 虚机
    静 整 (*q)[m] = &B; // 好 :块作用域/自动存储期 虚机
}

构 标签 {
    整 z[n]; // 错误: 变长数组 结构体成员
    整 (*y)[n]; // 错误: 虚机 结构体成员
};

外 整 x[]; // x 的类型是&l双引号;边界未知的 整 数组&r双引号;
整 a[] = {1,2,3}; // a 的类型是&l双引号; 3 个 整 的数组&r双引号;

构 s { 整 n; 双精 d[]; }; // s.d 是柔性数组成员
构 s *s1 = 分配(的大小 (构 s) + (的大小 (双精) * 8)); // 如同 d 是 d[8]

又 整 A[2][3];
常 A a = {{4, 5, 6}, {7, 8, 9}}; // 常 整 的数组的数组
整* π = a[0]; // 错误: a[0] 拥有类型 常 整*

整 a[3] = {1,2,3}, b[3] = {4,5,6};
整 (*p)[3] = &a; // 好 ,可以取地址
// a = b;            // 错误,a 是数组
构 { 整 c[3]; } s1, s2 = {3,4,5};
s1 = s2; // 好 :可以赋值拥有数组成员的结构体

整 a[3] = {1,2,3};
整* p = a;
打印格式("%zu\n", 的大小 a); // 打印数组大小
打印格式("%zu\n", 的大小 p); // 打印指针大小

空 f(整 a[], 整 sz) // 实际上声明 空 f(整* a, 整 sz)
{
    对(整 i = 0; i < sz; ++i)
       打印格式("%d\n", a[i]);
}
整 主(空)
{
    整 a[10];
    f(a, 10); // 转换成 整* ,传递指针
}

// 2 个元素为 3 个 整 的数组的数组
整 a[2][3] = {{1,2,3},  // 可视作行主导排列的
               {4,5,6}}; // 2x3 矩阵

整 a[2][3]; // 2x3 矩阵
整 (*p1)[3] = a; // 指向首个 3 个元素行的指针
整 b[3][3][3]; // 3x3x3 立方体
整 (*p2)[3][3] = a; // 指向首个 3x3 平面的指针

整 n = 10;
整 a[n][2*n];

整 n = 5;
整 m = 7;
大小型 sz = 的大小(整 (*)[n++]); // n 可以自增也可以不自增