数组原理及使用

数组

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

1.1数组的创建

数组是一组相同类型元素的集合。数组的创建方式：

type_t   arr_name   [const_n];
//type_t 是指数组的元素类型
//const_n 是一个常量表达式，用来指定数组的大小

数组创建的举例：

//代码1
int arr1[10];

//代码2
char arr2[10];
float arr3[1];
double arr4[20];

注：数组创建，在C99标准之前， [] 中要给一个常量才可以，不能使用变量。在C99标准支持了变长数组的概念，数组的大小可以使用变量指定，但是数组不能初始化。所以下列代码就是经典的错误：

int count = 10;
int arr[count];

1.2数组的初始化

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

int arr1[5] = {0}; //不完全初始化默认全给0
int arr2[5] = {1，2，3，4，5}; //完全初始化

数组在创建的时候如果想不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确定：

int arr1[] = {1，2，3，4，5}；
char arr2[] = {'a','b','c'};.
char arr3[] = "abcdef";

1.3 一维数组的使用

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

我们来看代码：

#include <stdio.h>
int main()
{
 int arr[10] = {0};//数组的不完全初始化
 //计算数组的元素个数
 int sz = sizeof(arr)/sizeof(arr[0]);
 //对数组内容赋值,数组是使用下标来访问的，下标从0开始
 int i = 0;
 for(i=0; i<10; i++)//这里的10如果换成变量sz更好
 {
 	arr[i] = i;
 } 
 //输出数组的内容
 for(int i=0; i<10; ++i)
 {
 	printf("%d ", arr[i]);
 }
 return 0;
}

1.4 sizeof函数的使用

在上例代码中，含有sizeof函数这里就简要说明一下该函数的使用方法:

sizeof的作用就是计算数组元素的个数。例如：

int arr5[10] = {1,2,3,4,5};
printf("%d\n",sizeof(arr5));  
printf("%d\n",sizeof(arr5[0]));
printf("%d\n", sizeof(arr5) / sizeof(arr5[0])); 

数组名计算的是:整个数组的大小,单位是字节 。

sizeof括号内加数组名，计算的便是整个数组的大小。

我们知道arr【】表示数组中的一个元素，则上述代码中的sizeof(arr5[0])表示的就是一个元素的大小。

所以，我们就可以顺理成章的知道了数组的大小除以数组一个元素的大小，表示的就是数组元素的个数了:例如上述代码中的 sizeof(arr5) / sizeof(arr5[0])。

总结：

1. 数组是使用下标来访问的，下标是从0开始
2. 数组的大小可以通过计算得到
3. 数组名后的中括号，里面放的是数组的下标

1.5一维数组在内存中的存储

接下来我们来观察数组在内存中的存储：

#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;
}

输出结果如下：

从结果我们可以发现，一个整形int占用4个字节，arr数组从第一个开始，地址往后依次加4个字节。

由此可知，我们可以得出结论：数组在内存中是连续存放的。

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

2.1 二维数组的创建

二维数组的创建，其后面的两个中括号依次是行和列，简称前行后列。如arr[c] [r]，就表示c行r列。

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

2.2二维数组的初始化

二维数组如果有初始化，行可以省略，列不能省略。例如下列代码中数组的arr3：

//数组初始化
int arr1[3][4] = {1,2,3,4};
int arr2[3][4] = {{1,2},{4,5}};
int arr3[][4] = {{2,3},{4,5}};

2.3二维数组的使用

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

#include <stdio.h>
int main()
{
    int arr[3][5] = {0};  //创建3行5列二维数组
    for(int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 5; ++j)
        {
            scanf("%d",&arr[i][j]);  //为二维数组手动赋值
        }
    }
    for(int i = 0;i < 3;i++)
    {
        for (int j = 0; j < 5; ++j)
        {
            printf("%d",arr[i][j]); //打印二维数组
        }
        printf("\n");
    }
}

输出结果如下：

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

#include <stdio.h>
int main()
{
 	int arr[3][4];
 	int i = 0;
 	for(i=0; i<3; i++)
 	{
		int j = 0;
 		for(j=0; j<4; j++)
 		{
 			printf("&arr[%d][%d] = %p\n", i, j,&arr[i][j]);
 		}
 	}
 	return 0;
}

输出结果如下：

从输出结果可以发现二维数组和一维数组的地址存储时类似的，对于一个int型数组，每个数组元素的地址相差均为4个字节。通过结果我们可以分析到，其实二维数组在内存中也是连续存储的。

3.数组越界

数组的下标是有范围限制的。

数组的下规定是从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1。所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。

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

#include <stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int i = 0;
    for(i = 0; i <= 10; i++)
    {
        printf("%d\n", arr[i]);//当i等于10的时候，越界访问了
    }
    return 0;
}

二维数组的行和列也可能存在越界。

4.数组作为函数参数

往往我们在写代码的时候，会将数组作为参数传个函数，比如：我要实现一个冒泡排序函数将一个整形数组排序。那我们将会这样使用该函数：

这里补充一下什么是冒泡排序：

通过对待排序序列从前向后（从下标较小的元素开始）,依次对相邻两个元素的值进行两两比较，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就如果水底下的气泡一样逐渐向上冒。

4.1冒泡排序的错误设计

#include <stdio.h>
void bubble_sort(int arr[])
{
    int sz = sizeof(arr)/sizeof(arr[0]);//这样对吗？
    int i = 0;
    for(i=0; i<sz-1; i++)
    {
        int j = 0;
        for(j=0; j<sz-i-1; j++)
        {
            if(arr[j] > arr[j+1])
             {
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
             }
        }
    }
}
int main()
{
    int arr[] = {3,1,7,5,8,9,0,2,4,6};
    bubble_sort(arr);//是否可以正常排序？
    int i = 0;
    for(i=0; i<sizeof(arr)/sizeof(arr[0]); i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

这段代码是不能够按照我们预想的效果进行排序的，遇到错误不要慌

通过调试结果发现，sz本应该是10，结果调试发现这里的sz结果是2。原因就是：arr数组作为了参数进行函数传参，传递的不是数组内容，其传递的本事而是数组首元素的地址.这里就有了不同：

在64位机器中指针的大小为8个字节

而在32位机器中，指针大小为4个字节。

因为我是在64位编译器下进行的，所以sizeof(arr)的大小为8，sizeof(arr[0])是int型大小恒定为4，所以我这里的输出结果为2。下面我用vs2022来模拟一下在写x86_32位环境下运行：

从调试结果可以发现，sz的值变成了1.

这里就不经有个疑问了：难道数组作为函数参数的时候，不是把整个数组的传递过去吗？

4.2数组名是什么

通过代码进行测试：

#include <stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5};
    printf("%p\n", arr);
    printf("%p\n", &arr[0]);
    printf("%d\n", *arr);
    //输出结果
    return 0;
}

结论：

数组名是数组首元素的地址。（有两个例外）

1. sizeof(数组名)，计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数组。

2. &数组名，取出的是数组的地址。&数组名，数组名表示整个数组。

除此1,2两种情况之外，所有的数组名都表示数组首元素的地址。

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

当数组传参的时候，实际上只是把数组的首元素的地址传递过去了。所以即使在函数参数部分写成数组的形式： int arr[] 表示的依然是一个指针： int *arr。那么，函数内部的 sizeof(arr) 结果是8.

此时知道了错误的地方，我们就可以改正为正确的代码了：

#include <stdio.h>
void bubble_sort(int arr[],int sz)
{
    for(int i=0; i<sz-1; i++)
    {
        for(int j=0; j<sz-i-1; j++)
        {
            if(arr[j] > arr[j+1])
             {
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
             }
        }
    }
}
int main()
{
    int arr[] = {3,1,7,5,8,9,0,2,4,6};
    int sz = sizeof(arr)/sizeof(arr[0]);
    bubble_sort(arr,sz);
    for(int i=0; i<sizeof(arr)/sizeof(arr[0]); i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

可以发现排序成功！！！