零、引言
本章重点:
1. 一维数组的创建和初始化
2. 一维数组的使用
3. 一维数组在内存中的存储
4. 二维数组的创建和初始化
5. 二维数组的使用
6. 二维数组在内存中的存储
7. 数组作为函数参数
一、 一维数组的创建和初始化
数组的创建
数组是一组相同类型元素的集合。
数组的创建方式:
type_t arr_name [const_n];
//type_t 是指数组的元素类型
//const_n 是一个常量表达式,用来指定数组的大小
数组创建实例:
//代码1
int arr1[10];
//代码2
int count = 10;
int arr2[count];//数组时候可以正常创建?
//代码3
char arr3[10];
float arr4[1];
double arr5[20];
注:数组创建, [] 中要给一个常量才可以,不能使用变量。
如此处的代码2,系统会提示,应输入常量表达式。
这里如果我写const int count = 10,就可以了,
使用常变量。
数组的初始化
数组的初始化是指,在创建数组的同时给数组的内容一些合理初始值(初始化)。
如:
整型数组
int arr1[10] = {1,2,3};//整型数组不完全初始化,剩下的元素默认初始化为0。
字符型数组
方法1
char arr2[5] = {'a','b'};//字符型数组不完全初始化,剩下的元素默认初始化为0。
方法2
char arr3[5] = "ab";//另一种初始化方式,这种初始化方式会在最后一个字符后面自动放上一个‘\0’,这以后,剩下的元素才是0。
方法3
char arr4[5] = {'a',98};//字符型数组里面可以直接放数字,这里的数字是某个字符对应ASCII码,输出的时候会输出对应字符。
方法4
char arr5[] = "abcdef";//这里不预先写数组大小,给定元素后自动计算;如这里的数组大小就是7,分别是‘a’ ‘b’ ‘c’ ‘d’ ‘e’ ‘f’ '\0'
这里,sizeof(arr5) = 7,
strlen(arr5) = 6。
strlen是求字符串长度的-只能针对字符串求长度-库函数-使用得引头文件
sizeof计算变量、数组、类型的大小-单位是字节-操作符
数组在创建的时候如果想不指定数组的确定的大小就得初始化。
数组的元素个数根据初始化的内容来确定。
但是对于下面的代码要区分,内存中如何分配。
char arr1[] = "abc";
char arr2[] = { 'a','b','c' };
cout << sizeof(arr1)<<endl;
cout << sizeof(arr2) << endl;
cout << strlen(arr1) << endl;
cout << strlen(arr2) << endl;
这里输出值为:4,3,3,15(随机值)
arr1 a b c \0 占了四个字节的空间 字符串长度为3
arr2 a b c 占了三个字节的空间 从a开始向后数,直到找到了一个‘\0’为止,计算‘\0’前面所有元素的个数,即字符串长度
二、 一维数组的使用
#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,好不好?
{
arr[i] = i;
}
//输出数组的内容
for(i=0; i<10; ++i)
{
printf("%d ", arr[i]);
}
return 0;
}
总结:
数组的大小可以通过计算得到:
int size = sizeof(arr)/sizeof(arr[0]);
三、一维数组在内存中的存储
接下来我们探讨数组在内存中的存储。 看代码:
#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;
}
输出的结果如下:
仔细观察输出的结果,我们知道,随着数组下标的增长,元素的地址,也在有规律的递增。
由此可以得出结论:
数组在内存中是连续存放的。
四、 二维数组的创建和初始化
二维数组的创建
//数组创建
int arr[3][4];
char arr[3][5];
double arr[2][4];
二维数组的初始化
//数组初始化
int arr[3][4] = {1,2,3,4};
int arr[3][4] = {{1,2},{4,5}};
int arr[][4] = {{2,3},{4,5}};
其中,二维数组可以省略行,不能省略列。
五、 二维数组的使用
二维数组的使用也是通过下标的方式。
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]);
}
}
return 0;
}
六、 二维数组在内存中的存储
像一维数组一样,这里我们尝试打印二维数组的每个元素。
#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:
#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);//是否可以正常排序?
for(i=0; i<sizeof(arr)/sizeof(arr[0]); i++)
{
printf("%d ", arr[i]);
}
return 0;
}
方法一中,出了问题。
调试后我们看到bubble_sort函数内部的sz,是1。
难道数组作为函数参数的时候,不是把整个数组传递过去?
数组名是什么?
#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5 };
printf("arr= %p\n", arr);
printf("&arr[0]= %p\n", &arr[0]);
printf("*arr= %d\n", *arr);
//输出结果
return 0;
}
输出结果是:
不同于前面我们学的变量传参,
数组传参并不是把数组拷贝一份,因为这样会浪费很多地址空间;
数组传参实际上传递过去的是数组的首元素地址。
如: bubble_sort(arr);
传过去的就是arr首元素的地址。
也就是说,本质上,bubble_sort(int arr[]);
这个int arr[]是一个指针,其实等价于int* p,而p指向的是arr这个数组的首元素地址。
结论:
数组名是数组首元素的地址。(有两个例外)
但是数组名也和一般的指针有区别。
如果数组名是首元素地址,那么:
int arr[10] = {0};
printf("%d\n", sizeof(arr));
为什么输出的结果是:40?
补充:
1.sizeof(数组名),计算整个数组的大小,sizeof内部单独放一个数组名,数组名表示整个数 组。
2. &数组名,取出的是整个数组的地址。&数组名,这里的数组名表示整个数组。
也就是说,从值上来看&arr = arr = &arr[0],但是表达的意思是不同的:
arr和&arr[0]表示的是arr这个数组的首元素地址,即1的地址,=004FF994,从1开始,从1结束;
但是&arr虽然值也是004FF994,但是它表示的是整个arr数组的地址,即从1开始,从7结束这整个一大块的地址。
举第二个例子就完全明白了:
arr+1和&arr[0]+1表示的都是第二个元素的地址,
但是&arr+1表示的是,经过了这整个数组以后的下一块地址。
我们可以算一下:arr[0]的地址是0,arr[6]的地址是24,
而&arr+1是28,印证了这一点。
除1,2两种情况之外,所有的数组名都表示数组首元素的地址。
冒泡排序的正确设计(有算法改进)
当数组传参的时候,实际上只是把数组的首元素的地址传递过去了。
所以即使在函数参数部分写成数组的形式: int arr[] 表示的依然是一个指针: int *arr 。
那么,函数内部的 sizeof(arr) 结果是4。
如果方法1错了,该怎么设计?
在外面求好,传参进去即可。
//方法2
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;
}
这里对冒泡排序进行了改进:
写一个flag,如果在排序的过程中,某一趟排序已经排好了,
那么后面的排序就没有必要再进行了。
void bubble_sort(int v[], int length)
{
for (int i = length; i > 1; --i)
{
int flag = 1;//假设这一趟要排的数据已经有序
for (int j = 0; j < i - 1; j++)
{
if (v[j] > v[j + 1])
{
int temp = 0;
temp = v[j + 1];
v[j + 1] = v[j];
v[j] = temp;
flag = 0;//本趟排序的数据其实不完全有序
}
}
if (flag == 1)//如果已经有序,不用再进行后面的循环了,跳出即可。
{
break;
}
}
}
八、对:C语言入门笔记 第六讲【函数-练习题】中存疑题的解答
1、一个函数中形参含有数组,以这道题为例,前面学习了如果想要对实参进行数值改变,那么形参应该传入实参的地址,再用解引用操作符在函数中改变实参,可是对于数组,这里我没有传入数组的地址,只是写了一个传值引用,可是最后实参数组的值还是被改变了,为什么?
这是因为,其实数组名是一个指针,指向首元素的地址,并不是像实参一样就是一个实际的参数。所以不需要专门写一个指针。
这里有两种写法:
1、传递参数是一个数组。
void bubble_sort(int v[], int length);
2、传递参数是一个指针。
void bubble_sort(int* v, int length);
因为数组名本身是指针,所以传过去即可。
2、在数组函数中,我的v[]是抽象的,是形参,原本里面定义了一个length = sizeof(v) /sizeof(v[0]),可是打印出来的结果是1,我期望这个函数里的形式length会在传入实参后,计算实参数组的长度,可是办不到,导致我需要在排序函数中再传入一个值,也即数组的长度。为什么?
因为传过去的v实质上是一个int型指针,里面存放了地址,占4个字节;而v[0]是一个数,也占4个字节,所以无论怎么除,值都是1。
3、数组指针问题。
这个问题留到指针章节再进行疑难解答。