数组
数组是指一组相同类型元素的集合。
1、一维数组的创建和初始化
1）数组的创建
type_t arr_name [const_n]
//type_t 是指数组的元素类型
//arr_name 是数组的名字
//const_n 是一个常量表达式，用来指定数组的大小
注：[ ]中要给一个常量才可以，不能使用变量。访问数组时[ ]中可以用变量。
int arr1[10]; //创建整型数组，含10个元素。
char ch1[4]; //创建字符数组，含4个元素。
double arr2[5]; //创建双精度浮点数数组，含5个元素。此时创建的数组内容随机。
2）数组的初始化
数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）。
int arr3[10] = { 1,2,3,4,5,6,7,8,9,10 }; //完全初始化。
int arr4[10] = { 1,2,3,4,5 }; //不完全初始化，后五个数字默认是0。
int arr5[] = { 1,2,3,4,5 }; //效果等同于 int arr5[5] = { 1,2,3,4,5 }; 自动计算元素个数。
char ch2[5] = { 'a','b','c' }; //不完全初始化，后面默认是 '\0'。
char ch3[5] = "abc"; //不完全初始化，后面默认是 '\0'。
char ch4[] = { 'a','b','c' }; //完全初始化。
char ch5[] = "abc"; //完全初始化，后面默认跟一个'\0'。
数组创建时若不初始化，里面的值是随机的，不易控制，一般都建议给个初始值。
2、一维数组的使用
数组通过下标引用操作符 [ ] 引用。
数组的下标从0开始计算。
访问数组时可以使用变量，如 [ i ]。
int arr[10] = { 0 }; //创建整型数组，含10个元素，均为0。
arr[4] = 2; //给第五个数赋值 2。
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr[i]); //打印结果 0 0 0 0 2 0 0 0 0 0 。
}创建数组时的[ ]里面只能是常数，如10。后续引用数组时，[ ]内可以用变量，如 i 。
3、一维数组在内存中的存储
一维数组在内存中是连续存放的。
随着数组下标的增长，地址是由低到高变化的。
指针类型和数组数据类型一致时，数组指针加1会跳到下一个元素。
#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("&arr[%d] = %p\n", i, &arr[i]);
}
//&arr[0] = 00B5FABC 地址以16进制数字表示。
//&arr[1] = 00B5FAC0 一个整型数值占用4个字节。
//&arr[2] = 00B5FAC4 一个地址可以存放1个字节。
//&arr[3] = 00B5FAC8 可以看到每个数字占用4个地址。
//&arr[4] = 00B5FACC
//&arr[5] = 00B5FAD0
//&arr[6] = 00B5FAD4
//&arr[7] = 00B5FAD8
//&arr[8] = 00B5FADC
//&arr[9] = 00B5FAE0
return 0;
}可以看到地址以16进制数表示，里面的元素地址依次增加，每个元素占4个地址，即整型元素占4个字节。
#include <stdio.h>
//按一维数组内存地址打印整型一维数组
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ",*p); //打印结果1 2 3 4 5 6 7 8 9 10 。
p++;
}
return 0;
}int* 指针+1 ，为跳到地址 +4的位置，即下一个整型元素。
4、二维数组的创建和初始化
1）二维数组的创建
type_t arr_name [const_n] [const_m]
//type_t 是指数组的元素类型
//arr_name 是数组的名字
//const_n 是一个常量表达式，用来指定数组的行数
//const_m 是一个常量表达式，用来指定数组的列数
注：[ ]中要给一个常量才可以，不能使用变量。
//二维数组的创建
int arr[3][4]; //创建一个二维整型数组，三行四列。
char ch[4][10]; //创建一个字符真行数组，四行十列。同一维数组一样，这时创建的元素值是随机的。
2）二维数组的初始化
二维数组可以像一维数组一样初始化。
二维数组可以分成几个一维数组初始化。
二维数组的行可以省略，列不能省略。
//二维数组的初始化
int arr1[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
int arr2[3][4] = { 1,2,3,4,5,6,7,8,9,10 }; //不完全初始化，后面补0 （字符是\0）
int arr3[3][4] = { {1,2},{2,2},{3,2} }; //不完全初始化，每行后面补0 （字符是\0）
int arr4[][4] = { 1,2,3,4,5,6,7,8,9 }; //不完全初始化，三行，后面补0 （字符是\0）
int arr5[][4] = { {1,2},{2,2} }; //不完全初始化，两行，每行后面补0 （字符是\0）
//int arr6[3][] = { 1,2,3,4,5,6 }; //报错二维数组可以像一维数组一样，按顺序初始化，每一行尾之后是下一行头。也可以直接按行初始化。
行可以省略，是因为二维数组在内存中是按序存储元素，一行结束进入下一行，只要知道列数，这一行占用的空间就明确了，就能知道下一行的地址。列不可以省略，因为若不知道占用多少列，就没法计算下一行从哪里开始，无法确定下一行的地址。
5、二维数组的使用
数组通过下标引用操作符 [ ] 引用。
数组的行号下标从0开始计算，列号下标也从0开始计算。
访问数组时可以使用变量，如 [ i ]
int arr1[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
printf("%d \n", arr1[1][1]); //打印结果是6，即第二行第二列数字。
int i = 0;
int j = 0;
for (i = 0;i < 3;i++)
{
for (j = 0; j < 4; j++)
printf("%-2d ", arr1[i][j]);
printf("\n");
}
//打印结果是
//1 2 3 4
//5 6 7 8
//9 10 11 12创建数组时的[ ]里面只能是常数，如3、4。后续引用数组时，[ ]内可以用变量，如 i，j 。
6、二维数组在内存中的存储
二维数组的每一行元素在内存中是连续存放的，前后两行在内存中也是连续存放的。因此要明确每行元素数量（列数），才能知道下一行从哪里开始，即初始化时列数不可省略。
随着数组下标的增长，地址是由低到高变化的。
#include <stdio.h>
//二维数组在内存中的存储
int main()
{
int arr[2][3] = { 1,2,3,4,5,6 };
int i = 0;
int j = 0;
for (i = 0; i < 2; i++)
{
for (j = 0; j < 3; j++)
{
printf("&arr[%d][%d] = %p\n", i, j, &arr[i][j]);
}
}
//打印结果
//&arr[0][0] = 00B2F980 地址以16进制数字存放。
//&arr[0][1] = 00B2F984 一个整型数值占用4个字节。
//&arr[0][2] = 00B2F988 一个地址可以存放1个字节。
//&arr[1][0] = 00B2F98C 可以看到二维数组按行是连续排列的。
//&arr[1][1] = 00B2F990 二维数组每行尾到下行头也是连续的。
//&arr[1][2] = 00B2F994
int* p = &arr[0][0];
//按二维数组内存地址打印整型二维数组。
for (i = 0; i < 6; i++)
{
printf("%d ", *p); //打印结果 1 2 3 4 5 6。
p++;
}
return 0;
}地址以16进制数表示，可以看到每个整型元素占用4个地址，即4个字节。整型指针+1，代表地址数+4。
7、数组作为函数参数
数组名是首元素的地址。作为函数参数时，以指针形式传参。所以函数内计算数组长度时使用 sz = sizeof（arr）/sizeof(arr[0])结果为1。想要数组长度，需在数组创建的位置计算。
1）sizeof(arr)时，数组名表示整个数组，计算的是整个数组的大小，单位是字节。
2）&数组名时，数组名表示整个数组，取出的是整个数组的地址。
#include <stdio.h>
//将数组中的元素按降序排列（数组下标引用）
void bubble_order(int arr[], int sz)
{
int i = 0;
int j = 0;
int flag = 1;
for (i = 0; i < (sz - 1); i++)
{
for (j = 0; j < (sz - 1 - i); j++)
{
if (arr[j] < arr[j + 1]) //这里arr[j] 相当于*（arr +j)。
{
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
flag = 0;
}
}
if (flag == 1)
{
break;
}
}
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_order(arr, sz);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr[i]); //打印结果10 9 8 7 6 5 4 3 2 1 。
}
return 0;
}sizeof(arr) 中，数组名代表整个数组，所以算出来是40。 sizeof（arr[0]），这时arr代表的就是数组首元素的地址了。
//将数组中的元素按降序排列(数组名 解引用）
void bubble_order(int arr[], int sz)
{
int i = 0;
int j = 0;
int flag = 1;
for (i = 0; i < (sz - 1); i++)
{
for (j = 0; j < (sz - 1 - i); j++)
{
if (*(arr+j) < *(arr+j + 1)) //*(arr + j) 相当于 arr[j]。
{
int tmp = *(arr + j);
*(arr + j) = *(arr + j + 1);
*(arr + j + 1) = tmp;
flag = 0;
}
}
if (flag == 1)
{
break;
}
}
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_order(arr, sz);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr[i]); //打印结果10 9 8 7 6 5 4 3 2 1 。
}
return 0;
}这里 arr[j] 相当于*（arr +j) 。arr+1 相当于 数组首元素地址+4，可见整型数组名与整型指针有相似特性。
#include <stdio.h>
//数组名含义
int main()
{
int arr[10] = { 0 };
printf("%d\n", sizeof(arr)); //打印结果是40。此时数组名代表整个数组。
printf("%d\n", sizeof(arr+1)); //打印结果是4。此时数组名未单独放在（）内，代表首元素地址。
printf("%p\n", &arr[0]); //打印结果 010FF844。此时数组名代表整个数组，0代表第1个元素。
printf("%p\n", &arr[0]+1); //打印结果 010FF848。此时打印的是第二个元素的地址。
printf("%p\n", arr); //打印结果 008FFD44。此时数组名代表首元素的地址。
printf("%p\n", arr+1); //打印结果 010FF848。此时打印的是第二个元素的地址。
printf("%p\n", &arr); //打印结果 010FF844。此时数组名代表整个数组。
printf("%p\n", &arr+1); //打印结果 010FF86C。此时打印的是数组下一个地址，16进制6C-44=28,10进制是40，也就是40个字节。
return 0;
}
可以看到，sizeof(数组名)时，数组名代表整个数组;数组元素取地址+1，代表的是数组下一个元素的地址；数组名+1，代表的是数组下一个元素的地址；对数组取地址 &数组名 时，数组名代表的是整个数组。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
