数组
数组是指一组相同类型元素的集合。
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,代表的是数组下一个元素的地址;对数组取地址 &数组名 时,数组名代表的是整个数组。