1. 一维数组
数组的创建和初始化
数组是一组相同类型元素的集合。数组创建的同时给一些初始值,这个过程叫初始化
一维数组的创建和初始化:
int main()
{
int a = 10;
int b = 20;
int c = 30;
int arr[5] = { 0 };//创建的5个元素,每一个元素都是int类型的,创建的时候给一些初始值的过程叫初始化。
int arr[10] = { 1,2,3 };//前三个初始化1 2 3 ,剩余的都是0。这叫不完全初始化
return 0;
}
char ch[b];这样的代码会报错,因为必须是一个常量。
c99标准之前,是不支持使用变量的,只能是常量。
c99中,添加了变长数组的概念,允许数组的大小是变量,而且要求编译器支持c99标准。vs对c99的支持就不好。
这里要再次深刻地理解一下strlen和sizeof函数。
strlen计算的是字符串的长度,关注字符串中是否由\0,计算的是\0之前的字符个数。
sizeof计算变量所占内存空间大小,只关注空间大小,不在乎\0。
int main()
{
char arr1[] = { 'a','b','c' };
//arr有3个元素,数组的大小是3个字节
printf("%d\n", strlen(arr1));//随机值,15
printf("%d\n", sizeof(arr1));//3
char arr2[] = "abc";
//arr2有四个元素,数组的大小是四个字节。
printf("%d\n", strlen(arr2));//3
printf("%d\n", sizeof(arr2));//4
return 0;
}
一维数组的使用
对于数组的使用我们之前介绍了一个操作符: [ ] ,下标引用操作符。它其实就数组访问的操作符。
我们来看代码:
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//下标:
printf("%d\n", arr[5]);//[]下标访问操作符,结果为6
//计算数组元素的个数:
int sz = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
总结:
- 数组是使用下标来访问的,下标是从0开始。
- 数组的大小可以通过计算得到
一维数组在内存中的存储
接下来对以下代码进行调试,看一看它在内存中的存储。
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int i = 0;
int* p = &arr[0];
for (i = 0; i < 10; i++)
{
printf("&arr[%d]=%p\n", i,&arr[i]);
//printf("%d ", *(p + i));
}
return 0;
}
1 一维数组在内存中连续存放。
2 数组随着下标的增长,地址是由低到高变化的。
2 二维数组
二维数组的创建和初始化
int main()
{
int arr[3][4] = { 0 };
int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};//初始化
int arr[3][4] = {1 ,2,3,4,5,6,};//不完全初始化
int arr[][4] = {1,2,3,4,5,6,7,8,9,10,11,12};//行可以省略,列不能省略
return 0;
}
二维数组在内存中的存储
初始化的时候,先把第一行的放完,再放第二行。
数据看似是分三行存放的,其实他就是一行存放的,而且是连续的。
二维数组的访问
int main()
{
int arr[3][4] = {0};
int i = 0;
for(i=0; i<3; i++)
{
int j = 0;
for(j=0; j<4; j++)
{
arr[i][j] = i*4+j;
}
}
for(i=0; i<3; i++)
{
int j = 0;
for(j=0; j<4; j++)
{
printf("%d ", arr[i][j]);//要访问的话,第一个元素的下标是arr[0][0]
}
}
return 0;
}
数组越界
数组的下标是有范围限制的。
数组的下规定是从0开始的,如果数组有n个元素,最后一个元素的下标就是n-1。
所以数组的下标如果小于0,或者大于n-1,就是数组越界访问了,超出了数组合法空间的访问。
C语言本身是不做数组下标的越界检查,编译器也不一定报错,但是编译器不报错,并不意味着程序就是正确的,所以程序员写代码时,最好自己做越界的检查。
int main()
{
int arr[10] = { 0 };
for (int i = 0; i <= 10; i++)
{
arr[i] = i;
}
printf("%d ", arr[10]);
return 0;
}
这里发现数组越界了,会发生报错。
c语言是支持多维数组的,但是使用的场景很少。
int main()
{
int arr[2][3][4];
return 0;
}
数组作为函数参数
往往我们在写代码的时候,会将数组作为参数传个函数,
比如:我要实现一个冒泡排序(这里要讲算法思想)
函数将一个整形数组排序。那我们将会这样使用该函数。
冒泡排序的思想:
两两相邻的元素进行比较,如果可能的话,需要交换
例如:9 8 7 6 5 4 3 2 1 0我要使用冒泡升序
8 9 7 6 5 4 3 2 1 0(8 9交换)
8 7 9 6 5 4 3 2 1 0(9 7交换)
。。。
8 7 6 5 4 3 2 1 0 9 这一组比较完了,最大的数字9,来到了最后
7 8 6 5 4 3 2 1 0 9
一趟冒泡排序搞定一个数字,让当前待排序的数组中的一个元素来到最终应该出现的位置上
如果有n个数字,需要n-1趟冒泡排序。
第一趟排序完成之后,待排序的对象就少了一个
第二趟排序完成之后,待排序的对象就少了两个
……
冒泡函数的设计
//传过来的是数组的首元素地址。
void bubble_sort(int arr[],int sz)
{
for (int i = 0; i < sz-1; i++)
{
//一趟冒泡排序的过程
for (int 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[10] = { 3,1,5,2,4,9,0,7,6,8};
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr,sz);//实际上,数组传参传递的不是整个数组,而是首元素的地址,
//按照这个地址,依然可以找到其他的元素
printf("%d\n", sz);
for (int i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
数组名
先上代码:
int main()
{
int arr[] = { 1,2,3,4,5 };
printf("%p\n", arr);//arr是数组首元素的地址
printf("%p\n", &arr[0]);//数组首元素的地址
printf("%p\n", &arr);
//值看起来一样,但是意义不一样!!
printf("%d\n",sizeof(arr));//20
printf("%p\n", arr+1);
printf("%p\n", &arr[0]+1);
printf("%p\n", &arr+1);//跳过了整个数组
}
运行结果如下:
数组名是首元素地址,但是两种情况除外
1 sizeof内部单独存放在一个数组名,数组名表示整个数组,sizeof(数组名)计算的是整个数组的大小。
2 &数组名,取出的是数组的地址。&数组名,数组名表示整个数组。
例如printf(“%p\n”, &arr+1);
&arr表示整个数组的地址,他的值和数组首元素地址是一样的,但是区别在于数组地址加了一个1,跳过了整个数组。数组首元素地址+1,只跳过4个字节。