数组：是一组相同类型元素的集合。
一维数组的创建
//数组创建方式 type_t arr_name [const_n];
type_t 是指数组的元素类型；
arr_name是数组名；
const_n 是一个常量表达式，用来指定数组的大小；
数组创建，[]中要给到一个常量才可以，不能使用变量。
创建的时候三个要素缺一不可。
int arr1[10]; int arr1[3+2]; char arr2[3]; float arr3[10]; double arr4[4];
？?那下面这个数组可以正常创建吗
1. int n = 0; 2. scanf("%d", &n); 3. int arr[n];
C99之前的数组只能是常量指定大小
C99之后引用了 变长数组 的概念，数组的大小是可以使用变量指定的
//但是在VS2022 2019不支持C99的变长数组
变长数组是不能初始化的。
一维数组的初始化
数组的初始化是指：在创建数组的同时给数组的内容一些合理初始化值（初始化）
int arr1[10] = {1,2,3};//不完全初始化 int arr2[] = {1,2,3,4};//根据初始化内容决定数组大小 int arr[2]={0}; int arr3[5] = {1，2，3，4，5}；//完全初始化 char arr4[3] = {'a',98, 'c'};//Ascll码 char arr5[] = {'a','b','c'};//没有\0 char arr6[] = "abcdef";//有\0 char arr1[] = "abc"; char arr2[3] = {'a','b','c'};
一维数组的使用
- 根据下标来访问
- 根据下标来修改数组
- 数组大小的计算
根据下标访问：
#include<stdio.h> int main() { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; int j = 0; for (j = 0; j < 10; j++) { printf("%d ", arr[j]); } return 0; }
根据下标来修改数组：
#include<stdio.h> int main() { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; //10,9,8,7,6,5,4,3,2,1 //0,1,2,3,4,5,6,7,8,9 int j = 0; for (j = 0; j <=9; j++) { arr[j] = 10-j; } for (j = 0; j <=9; j++) { printf("%d ", arr[j]); } return 0; }
数组元素大小的计算：
//数组中元素的个数的计算sizeof #include<stdio.h> int main() { int arr[] = { 1,2,3,4,5,6,7,8,9,10 }; printf("数组的空间大小：%d\n", sizeof(arr)); printf("数组中1个元素的大小：%d\n", sizeof(arr[7])); printf("数组中有多少个元素：%d\n", sizeof(arr)/sizeof(arr[7])); } //数组中元素的计算字符串sizeof和strlen #include<stdio.h> #include<string.h> int main() { char arr[] = "a,b,c"; printf("数组中元素的个数：%d\n", sizeof(arr) / sizeof(arr[0])); printf("数组中最右元素的下标：%d\n", sizeof(arr) / sizeof(arr[0]) - 2); //-2指的是下标从0开始和减去"\0" printf("数组中元素的个数：%d\n", strlen(arr)); //strlen是不计算"\0"的，需要包含头文件#include<string.h> printf("数组中最右元素的下标：%d\n", strlen(arr) - 1); //所以只要-1就是指的是下标从0开始 return 0; }
sizeof------------------- sz=sizeof(arr)/sizeof(arr[0]);
strlen-------------------- sz=strlen(arr);
一维数组在内存中的存储
如果想要知道一维数组在内存中的存储，我们需要将所有数组元素的地址打印在屏幕上。
//一维数组的存储 #include<stdio.h> int main() { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; int sz = sizeof(arr) / sizeof(arr[0]); int i = 0; for (i = 0; i < sz; i++) { printf("&arr[%d]:%p\n", i, &arr[i]); } return 0; }
- 数组在内存中是连续存放的
- 随着下标的增长，地址是由低到高变化的
二维数组的创建
//数组创建方式 type_t arr_name [const_n][const_n];
type_t 指的是数组元素类型
arr_name 指的是数组名字
const_n 一个常量表达式，用来指定数组元素大小
第一个[ ]是指行
第二个[ ]是指列
在初始化时 行 可以省略，列 不能省略。
int arr[3][4]; char arr[3][5]; double arr[2][4];
二维数组的初始化
//二维数组的初始化 #include<stdio.h> int main() { int arr1[3][4] = { 1,2,3,4 };//无{}小括号 int arr2[3][4] = { {1,2},{4,5} };//不完全初始化 int arr3[3][4] = { {1,2,3,4},{2,3,4,5},{3,4,5,6} };//完全初始化 int arr4[][4] = { {2,3},{4,5} };//省略行根据初始化内容确定行位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; int j = 0; for (i = 0; i <= 2; i++) { for (j = 0; j <= 4; j++) { printf("arr[%d][%d]:%d\n", i, j, arr[i][j]); } } return 0; }
根据下标来修改数组：
#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; int j = 0; for (i = 0; i <= 2; i++)//一行一行遍历 { for (j = 0; j <= 4; j++) { arr[i][j] = 5 * i + j + 1;//用下标找到元素，用元素元素赋值修改 } } for (i = 0; i <= 2; i++) { for (j = 0; j <= 4; j++) { printf("arr[%d][%d]:%d\n", i, j, arr[i][j]); } } return 0; }
二维数组在内存中的存储
#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; int j = 0; for (i = 0; i <= 2; i++) { for (j = 0; j <= 4; j++) { printf("arr[%d][%d]:%d\n", i, j, &arr[i][j]); } } return 0; }
二维数组在内存也是连续存放的。
- 二维数组其实是一维数组的数组
例如：arr[i][j]可以看成arr[i]是数组名 [j]是数组大小。
数组越界
数组的下标是有范围限制的。
数组的下标规定是从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1
所以数组的下标处于<0||>n-1就是数组越界访问了，超出了数组合法空间的访问.
即便编译器不会报错，它有容忍性。那是属于内存的错误 。
数组作为函数参数——冒泡排序
往往我们在写代码的时候，会将数组作为参数传给某个函数。
比如：我要实现一个冒泡排序函数将一个整形数组排序。将其倒序排列。
冒泡排序的思想：两两相邻的元素进行比较。
传统方式（无函数）
#include<stdio.h> int main() { int arr[10] = { 10,9,8,7,6,5,4,3,2,1 };//降序 int i = 0; int j = 0; int sz = sizeof(arr) / sizeof(arr[0]); //趟数 for (i = 0; i < sz-1; i++) { //每一趟的比较 for (j = 0; j < sz-1-i; j++) { //比较交换 if (arr[j] > arr[j + 1]) { int tmp = 0; tmp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = tmp; } } } for (j = 0; j <sz; j++) { printf("%d ", arr[j]); } return 0; }
未修改前函数传参
//请问以下代码可以运行结果正确吗？❌❌❌ #include<stdio.h> void bubble_sort(int arr[]) { int i = 0; int j = 0; int sz = sizeof(arr) / sizeof(arr[0]); //趟数 for (i = 0; i < sz - 1; i++) { //每一趟的比较 for (j = 0; j < sz - 1 - i; j++) { //比较交换 if (arr[j] > arr[j + 1]) { int tmp = 0; tmp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = tmp; } } } for (j = 0; j < sz; j++) { printf("%d ", arr[j]); } } int main() { int arr[10] = { 10,9,8,7,6,5,4,3,2,1 };//降序 bubble_sort(arr); return 0; }
为什么结果错误呢？
这里涉及到数组作为函数参数传参的知识了
数组名是什么？
数组名就是地址，通常来说：数组名就是数组首元素的地址。
例外：
sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节
&数组名，这里的数组名表示整个数组，取出的是整个数组的地址
除此之外，所有遇到的数组名都是数组首元素的地址
#include<stdio.h> int main() { int arr[5] = { 1,2,3,4,5 }; printf("%p\n", arr); printf("%p\n", arr+1); printf("%p\n", &arr); printf("%p\n", &arr+1); printf("%d\n", sizeof(arr)); return 0; }
修改之后函数传参
#include<stdio.h> void bubble_sort(int arr[],int sz) //这样写也可以 //void bubble_sort(int* arr,int sz) { int i = 0; int j = 0; //趟数 for (i = 0; i < sz - 1; i++) { //每一趟的比较 for (j = 0; j < sz - 1 - i; j++) { //比较交换 if (arr[j] > arr[j + 1]) { int tmp = 0; tmp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = tmp; } } } for (j = 0; j < sz; j++) { printf("%d ", arr[j]); } } int main() { int arr[10] = { 10,9,8,7,6,5,4,3,2,1 };//降序 int sz = sizeof(arr) / sizeof(arr[0]); bubble_sort(arr,sz);//arr这里不是特殊情况的两种，就是指首元素地址 return 0; }
以上两种写法均可，本质都是指正，第一种写法更容易学习和理解。
小游戏
我们学习完函数和数组的知识，我们将在接下来的博文里去实现到小游戏。🙂🙂🙂
- 汉诺塔
- 青蛙跳
- 三子棋
- 扫雷
✔✔✔✔✔✔感谢大家的阅读，有任何错误和不足欢迎指正！！！！
代码----------------------→【gitee：https://gitee.com/TSQXG】
联系----------------------→【邮箱：2784139418@qq.com】
