再学C语言41：变长数组（VLA）

处理二维数组的函数：数组的行可以在函数调用时传递，但是数组的列只能被预置在函数内部

示例代码：

#define COLS 4
int sum(int arr[][COLS], int rows)
{
    int r;
    int c;
    int temp = 0;

    for(r = 0; r < rows; r++)
    {
        for(c = 0; c < COLS; c++)
        {
            temp += arr[r][c];
        }
    }
    return temp;
}

假设定义数组array[3][4]，函数调用形式为：

sum_arr = sum(array, 3); // 行数可以以参数形式传递给参量rows

这是因为数组的维数必须是常量，不能用一个变量代替COLS

---

C99引入变长数组，允许使用变量定义数组各维

int a = 3;
int b = 4;
int array[a][b]; // 一个变长数组

变长数组的限制：必须是自动存储类，意味着变长数组必须在函数内部或作为函数参量声明，并且声明时不可以进行初始化

变长数组的大小不会变化：变长数组的大小在创建之后保持不变，“变”的意思是数组的维数可以使用变量进行指定

1）函数声明

如何声明带有一个二维变长数组参数的函数：

int sum(int r, int c, int arr[r][c]); // arr是一个变长数组
                                      // 前面两个参量作为数组参量arr的维数
                                      // 因为arr的声明中使用了r和c
                                      // 所以r和c的声明需早于arr

C99标准规定，可以省略函数原型中的名称；如果省略名称，需用*代替省略的维数

int sum(int, int, int arr[*][*]); 

2）函数定义

int sum(int r, int c, int arr[r][c])
{
    int i, j;
    int temp = 0;

    for(i = 0 ; i < r; i++)
    {
        for(j = 0; j < c; j++)
        {
            temp += arr[i][j];
        }
    }
    return temp;
}

区别古典C，函数定义时，用变量c代替常量COLS，因为使用了变长数组

3）函数使用

示例代码：

#include <stdio.h>

int sum(int r, int c, int arr[r][c]);

int main(void)
{
    int rows = 3;
    int cols = 5;
    int i, j;

    int array_1[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    int array_v[rows][cols];
    for(i = 0; i < rows; i++)
    {
        for(j = 0; j < cols; j++)
        {
            array_v[i][j] = i * j;
        }
    }

    printf("3 * 4 array:\n");
    printf("sum of all elements is %d\n", sum(3, 4, array_1));

    printf("3 * 5 VAL:\n");
    printf("sum of all elements is %d\n", sum(rows, cols, array_v));
}

int sum(int r, int c, int arr[r][c])
{
    int i, j;
    int temp = 0;

    for(i = 0; i < r; i++)
    {
        for(j = 0; j < c; j++)
        {
            temp += arr[i][j];
        }
    }
    return temp;
}

运行结果：

变长数组允许动态分配存储单元，可以在程序运行时指定数组的大小

常规的C数组是静态存储分配，数组大小在编译时已经确定（因为数组大小是常量，所以编译器可以得到这些信息）