C 语言—— 数组

1. 概念

数组是存放一组 相同类型 的 有序 数据的一段 连续 空间。

2. 声明

TYPE identifier[static(optional) qualifiers(optional) expression(optional)]
TYPE identifier[qualifiers(optional) static(optional) expression(optional)]

// farr 是一个包含 20 个元素的数组，元素的类型是 float
// pfarr 是一个包含 10 个元素的数组，数组的类型是 指向 float 的指针
float farr[20], *pfarr[10];

3. 分类

数组分为已知常量长度数组，变长度数组，以及未知大小数组。
1）expression 为整数常量表达式，则声明为已知常量长度数组：

// 声明一个包含 20 个类型为 float 的元素的数组，
// 整数常量 20 是常量表达式
float farr[20];

// sizeof 是常量表达式
char text[sizeof(double)];

// 枚举常量也是常量表达式
enum { MAX_SIZE = 100 };
int narr[MAX_SIZE];

2）expression 不是整数常量表达式，则声明为可变长度数组（VLA）：

int n = 0;

while(n++ < 10) {
    // 每次控制流经过该声明时会重新声明数组
    int a[n * 2];
    printf("The array has %zu elements\n", sizeof(a)/sizeof(*a));
    // 离开作用域 VLA 结束其生命周期
}

使用 * 作为 expression 时，声明为未指定长度的数组。这种声明只能出现在函数原型声明中。

void foo(size_t x, int a[*]);
void foo(size_t x, int a[x]) {
    // 这里 sizeof(a) 的大小等同于 sizeof(int*)
    printf("%zu\n", sizeof(a));
}

3. 若忽略 expression ，则声明为未知大小数组。
   未知大小数组 区别于 可变长度数组 的地方在于：可变长度数组 在其生命周期内，数组大小是不变的。

// 未知长度
extern int xarr[];
// 长度为 3
int iarr[] = {0, 1, 2};

未知大小数组可以作为 struct 的最后一个成员

struct s {
    int n;
    double d[];
};

void func() {
    struct s *s1 = malloc(sizeof(struct s) + sizeof(double) * 8);
    //...
}

4. 初始化

1. 列表初始化

int iarr0[] = {1, 2, 3}; // 3 个元素：1，2，3
int iarr1[5] = {1, 2, 3}; // 5 个元素：1，2，3，0，0
int iarr2[3] = {1};// 3 个元素：1， 0， 0
int iarr3[3] = {1, 2, 3, 4, 5}; // 3 个元素：1，2，3.

字符数组还可以使用字符串字面值来初始化。

// 10 个元素：
// 'H', 'e', 'l', 'l', 'o',
// '\0', '\0', '\0', '\0', '\0'
char str0[10] = "Hello";

2. 使用指派表达式
   使用指派表达式时，会先依次初始化指派表达式之前的元素（如果有的话），然后再初始化指派表达式指定的位置，最后再依次初始化指派表达式之后的位置。
   有点绕，看下面例子：

// 初始化后的 iarr0:
// 1, 0, 0, 0, 0, 
// 7, 0, 0, 11, 3, 
// 9, 0, 0, 0, 0
int iarr0[15] = {1, [5] = 7, [8] = 11, 3, 9};

5. 赋值

通过下标可以对数组元素进行赋值。

int iarr0[] = {1, 2, 3};
// 现在是：1，10，3
iarr0[1] = 10;

注意，尽管数组可以进行取值，但数组类型的对象并不是可修改类型，不可以作为左值。

int iarr1[3] = {1, 2, 3};
int iarr2[3] = {4, 5, 6};
// 取地址，可。
int (*parr)[3] = &iarr1;
// 对数组赋值，不可。
iarr1 = iarr2;

6. 附加语法

数组类型声明可以使用 const、volatile 或者 restrict 限定符来进行修饰，在 C23 之前此时数据类型无限定，但数组元素类型有限定，C23 开始数组类型与其元素类型有等同限定：

typedef int A[2][3];
const A a = {{4, 5, 6}, {7, 8, 9}};
// int const[3] 转 int *，不可。
int *pi = a[0];
// int const[2][3] 转 void *，
// 在 gcc 12.1 可以通过编译，
// 在 clang 13.1.6 无法通过编译。
void *unqual_ptr = a;

7. VLA 的一些补充

可变长数组类型（Variable Length Array, VLA）和指向可变长数组的指针类型称为可变修改类型（Variably Modified, VM）。

1. 任何可变修改类型的对象只能声明于 块作用域 或 函数原型作用域 中。

#define MAX_SIZE 100
extern int n;

// ...

// VLA 声明在文件作用域，不可
int A[n];
// 可
int B[MAX_SIZE];
// 指向 VLA 的指针，不可
extern int (*p2)[n];
// VLA 声明于函数原型作用域，可
void fvla(int m, int C[m]);

2. VLA 必须拥有自动或分配存储期。指向 VLA 的指针可以有静态存储期。 VM 类型不能拥有链接。
   (自动即定义在函数内并且不带auto以外存储类标识符修饰的对象；分配即通过 malloc、calloc、realloc 获得内存)

// int C[m] ：指向 VLA 的指针（自动存储期）；块作用域。可。
void func(int m, int C[m]) {
    // 块作用域，可。
    typedef int I_VLA[m][m];
    I_VLA ivla;
    // 块作用域；自动存储期。可。
    int D[m];
    // 块作用域；但静态。不可。
    static int E[m];
    // VLA 链接，不可。
    extern int F[m];
    // 块作用域；分配存储期。可。
    int (*s)[m];
    s = malloc(m * sizeof(int));
    // VM 链接，不可。
    extern int (*r)[m];
    // 指向 VLA 的静态指针。可。
    static int (*q)[m] = &B;
}

3. VM 不能作为联合（union）或者结构（struct）的成员。

void func(void) {
    int n = 5;

    // 错误的例子
    struct tag {
        // VLA 作为结构体成员，不可。
        int z[n];
        // VM 作为结构体成员，不可。
        int (*y)[n];
    };
}