0、总结
1、概念
数组：一组相同类型元素的集合。
- 数组中存放的是1个或多个数据，数组元素个数不能为0。
- 数组中存放的数据的类型都是相同的。
数组分为一维数组和多维数组，最常用的是一维数组和二维数组。
2、一维数组
1、创建和初始化
一维数组创建的基本语法：
type arr_name[常量值];
其中，type是数组中存放数据的类型，可以是char、int、float等，也可以自定义的类型。
数组如何初始化？
初始化：数组在创建的时候，需要给定一些初始值。
数组的初始化一般使用大括号，将数据放在大括号中。如下：
// 完全初始化
int arr[5] = { 1,2,3,4,5 };
// 不完全初始化
// 第一个元素初始化为1，剩余的元素默认初始化为0
int arr2[6] = { 1 };
// 错误的初始化 -初始化项太多
int arr3[3] = { 1,2,3,4 };
2、类型
数组是一种自定义类型，去掉数组名留下的东西是数组的类型。如下：
int arr1[10];
int arr2[12];
char ch[5];
arr1数组的类型是int [10]arr2数组的类型是int [12]ch数组的类型是char [5]
// 这段代码意在证明数组是有类型的
// 证明逻辑：sizeof(类型)如果成功运行，则存在。
#include <stdio.h>
int main()
{
char arr[5] = { 0 };
printf("%zd\n", sizeof(arr));
printf("%zd\n", sizeof(char[5]));
return 0;
}
输出：
5
5
3、使用
C语言规定数组有下标，下标从0开始，假设数组有n个元素，最后一个元素的下标是n-1。
下标相当于数组元素的编号，如下：
int arr[6] = { 1,2,3,4,5,6 };
数组访问元素提供了一个操作符[]，这个操作符称为下标引用操作符。
例如，访问下标3的元素，可以使用arr[3]，访问下标5的元素，可以使用arr[5]。
例1：
#include <stdio.h>
int main()
{
int arr[6] = { 1,2,3,4,5,6 };
printf("%d\n", arr[3]);
printf("%d\n", arr[5]);
return 0;
}
输出：
4
6
如果要访问数组的所有元素，该如何解决？
用for循环，让循环产生所有的下标，之后用下标访问数组元素即可。
例2：数组元素打印
#include <stdio.h>
int main()
{
int arr[6] = { 1,2,3,4,5,6 };
int i = 0;
for (i = 0; i < 6; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
输出：
1 2 3 4 5 6
例3：给数组输入数据
#include <stdio.h>
int main()
{
int arr[6] = { 1,2,3,4,5,6 };
int i = 0;
for (i = 0; i < 6; i++)
{
scanf("%d", &arr[i]);
}
for (i = 0; i < 6; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
输入：
3 4 5 6 7 8
输出：
3 4 5 6 7 8
4、内存中的存储
先打印数组元素的地址，如下：
#include <stdio.h>
int main()
{
int arr[5] = { 1,2,3,4,5 };
int i = 0;
for (i = 0; i < 5; i++)
{
printf("&arr[%d] = %p\n", i, &arr[i]);
}
return 0;
}
输出：
&arr[0] = 000000CD85CFFB68
&arr[1] = 000000CD85CFFB6C
&arr[2] = 000000CD85CFFB70
&arr[3] = 000000CD85CFFB74
&arr[4] = 000000CD85CFFB78
从输出的结果，我们知道数组随着下标的增长，地址是由小到大变化的，并且两个相邻的元素之间相差4（和类型有关系，一个整型4个字节），因此数组在内存中是连续存放的，为日后使用指针访问数组提供理论支持。
5、计算数组元素个数
在遍历数组时候，经常想知道数组的元素个数，这时运用sizeof来解决这个问题。
代码如下：
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
int sz = sizeof(arr) / sizeof(arr[0]);
printf("%d\n", sz);
return 0;
}
输出：
10
其中：
sizeof(arr)：计算数组所占内存空间的总大小，单位是字节。sizeof(arr[0])：计算数组的第一个元素所占内存空间的大小。sizeof(arr) / sizeof(arr[0])：数组的元素个数。
这样好处是，以后代码需要数组元素的地方不用固定写死，可通过以上的方法，数组无论怎么变化，计算的大小也随着变化而变化。
6、练习
例1：多个字符从两端移动，向中间汇聚
#include <stdio.h>
#include <windows.h>
#include <string.h>
int main()
{
char arr1[] = "welcome to world...";
char arr2[] = "*******************";
int left = 0;
int right = strlen(arr1) - 1;
printf("%s\n", arr2);
while (left <= right)
{
Sleep(700);
system("cls");
arr2[left] = arr1[left];
arr2[right] = arr1[right];
left++;
right--;
printf("%s\n", arr2);
}
return 0;
}
无法给输出，因为结果动态变化。
例2：二分查找
#include <stdio.h>
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int left = 0;
int right = sizeof(arr) / sizeof(arr[0]) - 1;
int key = 7;
int mid = 0;
int find = 0;
while (left <= right)
{
mid = left + (right - left) / 2;
if (arr[mid] > key)
{
right = mid - 1;
}
else if (arr[mid] < key)
{
left = mid + 1;
}
else
{
find = 1;
break;
}
}
if (1 == find)
{
printf("找到了，下标是%d\n", mid);
}
else
{
printf("找不到\n");
}
return 0;
}
输出：
找到了，下标是6
3、二维数组
1、概念
如果把一维数组作为数组的元素，这时候就是二维数组。如果把二维数组作为数组的元素，这时候就是三维数组。而二维数组以上的数组统称为多维数组。
2、创建和初始化
二维数组语法如下：
type arr_name[常量值1][常量值2];
例如：
int arr[3][5];
double data[2][8];
通俗理解：
二维数组
arr[3][5]，可以这样理解，有3个一维数组，一维数组里面有5个数组元素。三维数组
arr[3][4][5]，可以这样理解，有3个二维数组，二维数组里面有4个一维数组，一维数组里面有5个数组元素。
二维数组和一维数组一样，也是用大括号初始化。
例1：不完全初始化
int arr1[3][5] = { 1,2 };
int arr2[3][5] = { 0 };
例2：完全初始化
int arr3[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
例3：按照行初始化
int arr4[3][5] = { {1,2},{3,4},{5,6} };
例4：初始化时省略行，但不能省略列
int arr5[][5] = { 1,2,3 };
int arr6[][5] = { 1,2,3,4,5,6,7 };
int arr7[][5] = { {1,2},{3,4},{5,6} };
3、使用
二维数组访问也是使用下标，通过锁定行和列就能锁定数组里的一个元素。
在C语言中，二维数组的行是从0开始，列是从0开始。
例1：访问第2行第4列的元素。
#include <stdio.h>
int main()
{
int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
printf("%d\n", arr[2][4]);
return 0;
}
输出：
7
例2：二维数组的输入和输出。
#include <stdio.h>
int main()
{
int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
// 遍历行
int i = 0;
// 输入
for (i = 0; i < 3; i++) // 产生行号
{
int j = 0;
for (j = 0; j < 5; j++) // 产生列号
{
scanf("%d", &arr[i][j]); //输入数据
}
}
// 输出
for (i = 0; i < 3; i++) // 产生行号
{
int j = 0;
for (j = 0; j < 5; j++) // 产生列号
{
printf("%d ", arr[i][j]); //输出数据
}
printf("\n");
}
return 0;
}
输入：
5 5 5 5 5 6 6 6 6 6 7 7 7 7 7
输出：
5 5 5 5 5
6 6 6 6 6
7 7 7 7 7
4、内存中的存储
可以打印二维数组所有元素的地址，来观察二维数组在内存中的存储方式。
代码如下：
#include <stdio.h>
int main()
{
int arr[2][3] = { 0 };
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]);
}
}
return 0;
}
输出：
&arr[0][0] = 00000094C9AFF8E8
&arr[0][1] = 00000094C9AFF8EC
&arr[0][2] = 00000094C9AFF8F0
&arr[1][0] = 00000094C9AFF8F4
&arr[1][1] = 00000094C9AFF8F8
&arr[1][2] = 00000094C9AFF8FC
从输出的结果来看，二维数组中的每个元素都是连续存放的。了解清楚二维数组在内存中的布局，为日后使用指针访问数组打下基础。
4、C99的变长数组
在C99标准后，给一个变长数组（variable-length array，简称VLA）的新特性，允许可以使用变量指定数组大小。
变长数组的特征是，数组长度只有运行时才能确定，所以变长数组不能初始化。
如下：
int n = a + b;
int arr[n];
上面示例中，数组arr是变长数组，长度取决于变量n的值。编译器没法事先确定n，只有运行时才能知道n是多少。
值得一提，变长数组的意思是，在程序运行的时候，根据变量的大小来指定数组的元素个数，而不是说数组的大小是可变的。数组的大小一旦确定就不能再变化了。
完。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
