本章前言
目录
一、一维数组的创建和初始化
1.一维数组的创建
1.1数组的创建
数组是一组相同类型元素的集合。
数组的创建方式:
type_t arr_name [const_n];
//type_t 是指数组的元素类型
//arr_names 是数组名称
//const_n 是一个常量表达式,用来指定数组的大小
举些例子:
int arr1[10];
char arr2[5];
float arr3[3];
//正确创建
注意:创建数组时,[ ]里放的是常量,而不是变量。因为放变量,数组有可能越界访问非法内存
当[ ]里放变量:
在一些编译器中,[ ]中放变量并不会报错,也可正常编译执行,那是因为该编译器支持C99语法标准。C99语法标准中,变长数组——[ ]中可以是变量。
2.一维数组的初始化
数组的初始化是指,在创建数组的同时给数组的内容一些合理初始值(初始化)。
全局数组和局部数组不给予初始化:
全局数组:系统默认初始化为0
局部数组:编译器给出未初始化的警告,在窗口里看到其被赋一些无意义的数。
其他:
arr5:字符串初始化数组,在监视中看到会多一个’\0’,所以有4个元素
arr6和arr7:单独放字符初始化数组,因为arr7是字符型数组,编译器会自动将98解析为字符('b’的ACSII码值为98),arr6和arr7都是3个元素。
sizeof:计算的是数组的空间大小。arr5比arr6多一个’\0’,所以arr5的空间大小比arr6大1
strlen:计算的是字符的个数。strlen的结束标准是’\0’,且’\0’不计入字符个数。strlen(arr5)遇到’\0’就停止,长度为3;strlen(arr6):abc后没有’\0’,那么strlen就会一直计算下去,直到遇到内存中的’\0’才停止。
2.一维数组的使用
数组的使用: [] ,下标引用操作符。它其实就是数组访问的操作符。 我
们来看代码:
#include <stdio.h>
int main()
{
int arr[10] = {
0 };//数组的不完全初始化
int sz = sizeof(arr) / sizeof(arr[0]);//计算数组的元素个数:10
//对数组内容赋值,数组是使用下标来访问的,下标从0开始。所以:
int i = 0;//做下标
for (i = 0; i < sz; i++)//这里写10,好不好?
{
arr[i] = i;
}
//输出数组的内容
for (i = 0; i < 10; ++i)
{
printf("%d ", arr[i]);
}
return 0;
}
运行结果:
总结:
1.数组是使用下标来访问的,下标从0开始。
2.数组的大小可通过计算得到。//int sz = sizeof(arr) / sizeof(arr[0]);
3.一维数组在内存中的存储
接下来我们探讨数组在内存中的存储。 看代码:
#include<stdio.h>
int main()
{
int arr[10] = {
0 };
int i = 0;
for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
{
printf("&arr[%d] = %p\n", i, &arr[i]);
}
return 0;
}
运行结果:
可见,随着数组下标的增长,元素的地址,也在有规律的递增。可得结论:数组在内存中是连续存放的。
分析:
16进制与10进制的对应关系是:0-9对应0-9;A-F对应10-15。
地址都是16进制的,若转换成10进制,可见数组每个元素相差4(int整型变量的字节大小为4),因此一维数组里的元素在内存中是连续存放的,且地址在不断增大。同理char类型的数组在内存中也是连续存放的,但每个元素应相差1(char类型变量的字节大小为1)。
总结:
1.一维数组在内存中是连续存放的
2.随着数组下标的增长,地址由低到高。
二、二维数组的创建和初始化
1.二维数组的创建
type_t arr_name[const_n][const_n]
//数组创建
int arr[3][5];//3行5列
char ch[4][7];//4行5列
double arr2[2][4]//2行4列
可见,二维数组的语法结构:类型+数组名+[行][列],[ ]内放常量表达式。
当我们创建一个二维数组时,如int arr[3][4];
后,我们可以理解如下图:
2.二维数组的初始化
int main()
{
int arr1[3][4] = {
1,2,3,4,5,6,7,8,9,10 };//不完全初始化
int arr2[3][4] = {
1,2,3,4,5,6,7,8,9,10,11,12 };//完全初始化
return 0;
}
不完全初始化:没赋值的位置会自动赋值为0。
完全初始化:从头到尾将数值赋值给3×4的二维数组。
另外,从监视可看出,其实二维数组arr[3][4]是由三个一维数组构成且每个数组有4个元素(即一个一维数组有3个元素,而这3个元素的每一个元素内又含有4个元素)。
也可以用{ }来初始化:
int arr1[3][4] = {
{
1,2},{
3,4},{
5,6} };
int arr2[3][4] = {
{
1,2,3,4},{
5,6,7,8},{
9,10,11,12} };
二维数组看成多个一维数组,一个{ }对应一行(一个一维数组),同样没有初始化的元素会自动赋值为0。
思考:当初始化个数大于数组定义的个数时,会发生什么?
如:int arr[2][4];
arr有2×4个元素,但初始化了9个数值。
编译报错,报错说明是初始值设定项太多,且无法执行。
解析:编译器会检查初始值设定项是否大于数组的长度。数组创建需要向内存申请空间,若初始值设定项占用的空间大于数组申请的空间,就会"访问越界"。(比如数组申请一块32个字节的空间,我们在初始化给了9个int类型的值,即36个字节,超过了数组本身可以访问的空间大小)。
给字符数组初始化也是一样的道理,但要注意\0
char ch1[2][4] = {
'a','b' };
char ch2[2][4] = {
{
'a'},{
'b'} };
char ch3[3][4] = {
"abc","def","gh" };
注: 数组定义可省略行,但不可省略列。(下文解析)
int arr[][4] = {
{
2,3},{
4,5}};
3.二维数组的使用
二维数组的使用也是通过下标的方式。看代码:
#include<stdio.h>
int main()
{
int arr[3][4] = {
1,2,3,4,5,6,7,8,9,10,11,12 };
int i = 0;
for (i = 0; i < 3; i++)//0~2行
{
int j = 0;
for (j = 0; j < 4; j++)//0~3列
{
printf("%2d ", arr[i][j]);
}
printf("\n");
}
return 0;
}
运行结果:
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;
}
运行结果:
通过结果我们可以分析到,其实二维数组在内存中也是连续存储的。
连续存储:1.每一行内部的元素连续存放 2.行与行之间连续存放
理解上的储存形式:
实际上的储存形式:
二维数组int arr[3][4];
可看作由3个一维数组构成,这3个一维数组的数组名分别是arr[0],arr[1],arr[2]。
由数组访问成员的方式:数组名 + [下标]可知
若访问第一个一维数组中的第三个元素,即arr[0][2]
思考:二维数组在内存中是连续存放有什么作用?
1.上文提到int arr[][4];
可省略行,但不可省略列。
原因:二维数组存储的时候是"先行后列", 如果不指定列数, 它就不能知道一行放几个数据了。只要知道了列数, 全部放完就可以知道一共能放多少行。
2.因为二维数组在内存中是连续存放的,当我们拿到二维数组的首地址时,就可以访问这个数组所有的元素。(联系指针有关知识,指针变量+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 - 1 - i; j++)
{
if (arr[j] > arr[j + 1])
{
int temp = 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 i = 0;
bubble_sort(arr);//是否可以正常排序?
for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
{
printf("%d ", arr[i]);
}
return 0;
}
程序分析:调试之后可以看到bubble_sort函数内部的sz的值为1,arr的值为0x00cffd94(地址)。
小脑袋瓜在想:难道数组作为函数参的时候,不是把整个数组给传递过去吗?
四、关于数组名
数组名是什么?看代码:
结论:
数组名是数组首元素的地址。(但有两个例外)
①sizeof(数组名),计算整个数组的大小,sizeof内部单独放一个数组名,数组名表示整个数组。
②&数组名,取出的是数组的地址。&数组名,数组名表示整个数组。
除此①、②两种情况之外,所有的数组名都表示数组首元素的地址。
了解上面知识,我们可设计正确的冒泡排序函数:
设计思路: 当数组传参时,实际上只是把数组的首元素的地址给传递过去。
所以即使在函数参数部分写成数组的形式:int arr[ ]
,它表示的依然是一个指针,即:int *arr
。那么,bubble_sort函数内部的sizeof(arr)的结果是4。既然在bubble_sort函数内部计算sz不行,那么就在main主函数内计算sz,这时sizeof(arr)计算是整个数组的大小,再将sz传给函数,这样问题就解决啦!
void bubble_sort(int arr[], int sz)//参数接收数组元素个数
{
//...
}
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(i=0; i<sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}