数组-C语言

1. 一维数组的创建和初始化

1.1 数组的创建

数组是一组相同类型元素的集合。特点：

• 数组中的每个数据元素都是相同的数据类型。
• 数组是由连续的内存位置组成的。

数组的创建方式：

type_t arr_name[const_n];

type_t:数组的元素类型
const_n:一个常量表达式，用来指定数组的大小

数组创建的实例：

//代码1
int arr1[10];

//代码2
int count = 10;
int arr2[count];//数组什么时候可以正常创建？

//代码3
char arr3[10];
float arr4[1];
double arr5[20];

注意：

• 在 C99 标准之前，[ ]中 数组的大小必须是 常量 或者 常量表达式，不能使用变量。
• 在 C99 标准之后，数组的大小可以是变量，为了支持变长数组（数组的大小通过变量指定，不是指 数组可以改变大小）。

拓展 - 变长数组：

int n = 0;
scanf("%d", &n);
int arr[n];

int i = 0;
fot (i = 0; i < n; i++) {
    scanf("%d", &arr[i]);
}

特点：变长数组在声明时不能同时进行初始化。

1.2 数组的初始化

数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）。

int arr1[10] = {1, 2, 3};
int arr2[] = {1, 2, 3, 4};
int arr3[5] = {1, 2, 3, 4, 5};
char arr4[3] = {'a', 98, 'c'};
char arr5[] = {'a', 'b', 'c'};
char arr6[] = "abcdef";

• 数组在创建时如果不指定数组的大小就得初始化。数组的元素个数根据初始化的内容来确定。
• 不完成初始化的话，剩余的元素默认初始化为 0（字符为 '\0'）。
• 既不指定数组大小，又没有初始化的话存在语法错误，不算做数组。

但是对于下面的代码要区分，内存中如何分配。

char arr1[] = {'a', 'b', 'c'};//3
char arr2[] = "abc";          //4

注意：采用字符串来初始化字符数组时，字符串结束标志 '0' 算为字符数组中一个字符元素。

 1.3 数组的类型

int arr[10] = {0};

该数组的类型为 int [10]。 

 1.4 一维数组的使用

对于数组的使用我们之前介绍了一个操作符：[ ]，下标引用操作符。它其实就是数组访问的操作符。

#include <stdio.h>

int main() {
    int arr[10] = { 0 };
    int i = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);

    for (i = 0; i < sz; i++) {
        printf("&arr[%d] = %p\n", i, &arr[i]);
    }

    return 0;
}

 采用 sizeof(arr) / sizeof(arr[0]) 来计算数组的大小。

 观察输出的结果我们知道，随着数组下标的增长，元素的地址也在有规律的递增。由此得出结论：数组在内存中是连续存放的。

2. 二维数组的创建和初始化

2.1 二维数组的创建

int arr[3][4];
char arr[3][5];
double arr[2][4];

2.2 二维数组的初始化

int arr[3][4] = {1, 2, 3, 4};
int arr[3][4] = {{1, 2}, {4, 5}};
int arr[][4] = {{2,3}, {4,5}};

不完成初始化的话，剩余的元素默认初始化为 0（字符为 '\0'）。

注意：二维数组创建时如果有初始化，行可以省略，列不能省略。行数由初始化决定。

2.3 二维数组的使用

二维数组的使用也是通过下标的方式。

#include <stdio.h>

int main() {
    int arr[3][4] = { 1, 2, 3, 4, 2,3,4,5, 3,4,5,6 };
    int i = 0, j = 0;
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 4; j++) {
            printf("%d ", arr[i][j]);
        }
    }

    return 0;
}

能不能把二维数组看作一维数组呢？

        能，把二维数组中的 每一行（一维数组） 看作一个元素，可以把 二维数组 理解为 一维数组的数组。

2.4 二维数组在内存中的存储

像一维数组一样，我们打印二维数组中的每个元素。

#include <stdio.h>

int main() {
    int arr[3][4] = { 1, 2, 3, 4, 2,3,4,5, 3,4,5,6 };
    int i = 0, j = 0;
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 4; j++) {
            printf("arr[%d][%d] = %p\n", i, j, &arr[i][j]);
        }
    }

    return 0;
}

通过结果我们可以分析到，其实二维数组在内存中也是连续存储的。

3. 数组越界

数组的下标是有范围限制的：数组的下标访问是从 0 开始的，如果数组有 n 个元素，最后一个元素的下标就是 n - 1。

所以数组的下标如果小于 0，或者大于 n - 1，就是数组越界访问了，超出了数组合法空间的访问。

C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的，所以程序员写代码时，最后自己做越界检查。

#include <stdio.h>

int main() {
    int arr[3][4] = { 1, 2, 3, 4, 2,3,4,5, 3,4,5,6 };
    int i = 0, j = 0;
    for (i = 0; i < 3; i++) {
        for (j = 0; j <= 4; j++) {//当 j = 4 时，越界访问了
            printf("%d ", arr[i][j]);
        }
    }

    return 0;
}

4. 数组作为函数参数

往往我们在写代码的时候，会将数组作为参数传给函数。

比如：实现一个冒泡排序函数，将一个整型数组排序。

冒泡排序算法：

作用：最常用的排序算法，对数组内元素进行排序

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。
3. 重复以上的步骤，每次比较次数 -1，直到不需要比较。

4.1 冒泡排序函数的错误设计

#include <stdio.h>

void bubble_sort(int arr[]) {
    int sz = sizeof(arr) / sizeof(arr[0]);//这样做对么？
    int i = 0, j = 0;
    for (i = 0; i < sz - 1; i++) {
        //一轮冒泡排序
        for (j = 0; j < sz - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                //交换
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}

int main() {
    int arr[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
    
    //冒泡排序的核心思想：两个相邻的元素进行比较。
    //一轮冒泡排序让一个数据来到它最终应该出现的位置上。
    bubble_sort(arr);

    for (int i = 0; i < sz; i++) {
        printf("%d ", arr[i]);
    }

    return 0;
}

调试后我们看到 bubble_sort() 函数内部的 sz 是 1。难道数组作为函数参数的时候，不是把整个数组传递过去？ 

4.2 数组名是什么？

数组传参的时候，实参为数组名，数组名本质上是 数组首元素的地址，地址应该用指针变量来接收，所以函数的数组形参本质是 指针变量。

#include <stdio.h>

int main() {
    int arr[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };

    printf("%p\n", arr);
    printf("%p\n", &arr[0]);

    return 0;
}

二维数组的数组名也表示数组首元素的地址，此时的首元素为 第 0 行的一维数组，因此二维数组的数组名表示 第 0 行的一维数组 的地址。

#include <stdio.h>

int main() {
    int arr[][4] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };

    printf("%p\n", arr);
    printf("%p\n", arr + 1);

    printf("%d\n", sizeof(arr) / sizeof(arr[0]));//二维数组的行数
    printf("%d\n", sizeof(arr[0]) / sizeof(arr[0][0]));//二维数组的列数

    return 0;
}

数组名有两个例外：

1. sizeof(数组名)：这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节。
2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址。

#include <stdio.h>

int main() {
    int arr[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };

    printf("%p\n", arr);
    printf("%p\n", arr + 1);
    printf("----------------------\n");
    printf("%p\n", &arr[0]);
    printf("%p\n", &arr[0] + 1);
    printf("----------------------\n");
    printf("%p\n", &arr);
    printf("%p\n", &arr + 1);

    return 0;
}

4.3 冒泡排序函数的正确设计

#include <stdio.h>

void bubble_sort(int arr[], int sz) {
    int i = 0, j = 0;
    for (i = 0; i < sz - 1; i++) {
        //一轮冒泡排序
        for (j = 0; j < sz - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                //交换
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}

int main() {
    int arr[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    //冒泡排序的核心思想：两个相邻的元素进行比较。
    //一轮冒泡排序让一个数据来到它最终应该出现的位置上。
    bubble_sort(arr, sz);

    for (int i = 0; i < sz; i++) {
        printf("%d ", arr[i]);
    }

    return 0;
}

数组传参的时候，形参有 2 种写法：

1. 数组
2. 指针