数组——“C”
各位CSDN的uu们你们好呀，今天是个特别的日子，小雅兰开学了，但是开学并不意味着我就不更新文章了，哈哈哈。言归正传，小雅兰今天的内容是数组，数组当中的小知识点特别多，也算是C语言中比较重要的部分了，现在，就让我们一起进入数组的世界吧
Systrace
malloc
怎样定义一维数组
FISCO BCOS
一维数组的初始化
方法重载与方法重写的区别
一维数组的使用
实现
一维数组在内存中的存储
qt
怎样定义二维数组
H5
二维数组的初始化
Prim
二维数组的使用
基础知识
二维数组在内存中的存储
原型模式
数组越界
IPC
数组的应用实例
Spring Boot
- 之前我们学习的内容，使用的变量都属于基本类型，例如整型、字符型、浮点型数据，这些都是简单的数据类型。
- 对于有些数据，只用简单的数据类型是不够的，难以反映出数据的特点，也难以有效地进行处理。
下面，我们就引出了数组的概念：
python数据处理
- 数组是一组有序数据的集合。数组中各数据的排列是有一定规律的，下标代表数据在数组中的序号。
- 用一个数组名和下标唯一确定数组中的元素
- 数组中的每一个元素都属于同一个数据类型
怎样定义一维数组
情感分析
定义一维数组的一般形式为：
魔法方法
类型符 数组名 [常量表达式];
学习路径
数组名的命名规则和变量名相同
交易机器人
如 int a[10];
taro
其中，int表示每个元素的数据类型，a表示数组名，10表示数组长度
仿腾讯视频小程序
下面，我们来看看数组创建的实例
小程序订阅消息
int arr[10];//合法
int arr[4+6];//合法
这两种数组创建的方式都是合法的
表情识别
int count=10;
int arr2[count];
//这样的数组是否可以成功创建呢？我们用编译器来运行看看：
p2p
车牌识别
然后我们会发现，编译器报了一堆错误，小雅兰使用的编译器是VS2022，我的VS2022不支持这样的写法
openlayers
实际上，数组创建，在C99标准之前，数组的大小只能是常量来指定，例如int arr[10];
swiftui
在C99标准中，引入一个变长数组的概念，变长数组允许数组的大小使用变量 来指定，但是数组不能初始化
数据处理
很显然，在我的VS2022，这样的数组创建是不可以的
Kubectl
char arr3[10];
float arr4[1];
double arr5[20];
//这样的数组创建的方式都是非常ok的一维数组的初始化
wireshark
数组的初始化是指：在创建数组的同时给数组的内容一些合理初始值。
雷同率
int arr[10]={0,1,2,3,4,5,6,7,8,9,10};
andorid原生插件
int arr[10]={1,2,3};——不完全初始化，剩余的默认初始化为0——相当于
int arr[10]={1,2,3,0,0,0,0,0,0,0};
int arr[10]={1,2,3,4,5,6,7,8,9,10};——可写为
int arr[]={1,2,3,4,5,6,7,8,9,10};——这样的数组称为完全初始化
数组在创建的时候如果想不指定数组的确定的大小就得初始化，数组的元素个数根据初始化的内容来确定。
char arr[3]={'a',98,'c'};——98是'b'的ASCII码值——相当于
char arr[3]={'a','b','c'};
但是，对于下面的代码：
char arr[]="abc";——内存中表示a b c \0
char arr[3]={'a','b','c'};——内存中就表示a b c
一维数组的使用
对于数组的使用我们之前介绍了一个操作符： [] ，下标引用操作符。它其实就是数组访问的操作符。
下面，我们来看一小段代码
#include<stdio.h>
int main()
{
int arr[10]={0};//数组的不完全初始化
//计算数组的元素个数
int sz=sizeof(arr)/sizeof(arr[0]);
//这个sizeof(arr)计算的是数组的总大小
//对数组内容赋值，数组是使用下标来访问的，下标从0开始
int i=0;
for(i=0;i<10;i++)
{
arr[i]=i;
}
//输出数组的内容
for(i=0;i<10;i++)
{
printf("%d ",arr[i]);
}
return 0;
}其实，在这段代码中，我们计算数组中总元素的大小有两种写法：
printf("%d\n",sizeof(arr));//计算结果为40
printf("%d\n",sizeof(int [10]));//这样的写法也是可以的，计算结果仍然为40
下面，我们再来举个例子：
int a=10;
printf("%d\n",sizeof(a));//计算结果为4
printf("%d\n",sizeof(int));//这样的写法仍然是可以的，计算结果还是4
我们来复习一下之前学过的一个小知识点
#include<stdio.h>
int main()
{
printf("%d\n", sizeof(int));//4个字节
printf("%d\n", sizeof(char));//1个字节
printf("%d\n", sizeof(short));//2个字节
printf("%d\n", sizeof(long));//4个字节
printf("%d\n", sizeof(long long));//8个字节
printf("%d\n", sizeof(float));//4个字节
printf("%d\n", sizeof(double));//8个字节
printf("%d\n", sizeof(long double));//8个字节
return 0;
}
总结:
1. 数组是使用下标来访问的，下标是从0开始。
2. 数组的大小可以通过计算得到。
int arr[10];
int sz=sizeof(arr)/sizeof(arr[0]);
下面，我们来看一个题目：
例：对10个数组元素依次赋值为0，1，2，3，4，5，6，7，8，9，要求按逆序输出。
解题思路：
- 定义一个长度为10的数组，数组定义为整型
- 要赋的值是从0到9，可以用循环来赋值
- 用循环按下标从大到小输出这10个元素
#include<stdio.h>
int main()
{
int i=0;
int arr[10]={0};
for(i=0;i<10;i++)
{
arr[i]=i;
}
for(i=9;i>=0;i--)
{
printf("%d ",arr[i]);
}
printf("\n");
return 0;
}
一维数组在内存中的存储
话不多说，直接上代码：
#include<stdio.h>
int main()
{
int arr[10]={0};
int i=0;
int sz=sizeof(arr)/sizeof(arr[0]);
for(i=0;i<sz;i++)
{
printf("&arr[%d]=%p\n",&arr[i]);
}
return 0;
}下面来看看输出结果
仔细观察输出的结果，我们知道，随着数组下标的增长，元素的地址，也在有规律的递增。（由低到高变化）
由此可以得出结论：数组在内存中是连续存放的。
我们需要看得更清楚一点
#include<stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
int* p = &arr[0];
for (i = 0; i < sz; i++)
{
printf("%p==%p\n", p + i, &arr[i]);
}
return 0;
}
我们会发现p+i的地址和&arr[i]的地址完全一样
#include<stdi.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
int* p = &arr[0];
for (i = 0; i < sz; i++)
{
printf("%d ", *(p + i));
}
return 0;
}
怎样定义二维数组
二维数组定义的一般形式为
类型符 数组名 [常量表达式][常量表达式];
如：float a[3][4],b[5][10];
二维数组可被看作是一种特殊的一维数组；
它的元素又是一个一维数组；
例如：把a看作是一个一维数组，它有3个元素：a[0],a[1],a[2]
每个元素又是一个包含4个元素的一维数组
| a[0] | a[0][0] | a[0][1] | a[0][2] | a[0][3] |
| a[1] | a[1][0] | a[1][1] | a[1][2] | a[1][3] |
| a[2] | a[2][0] | a[2][1] | a[2][2] | a[2][3] |
二维数组的初始化
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,7,8,9,10};
int arr[3][4]={{1},{5},{9}};——相当于
int arr[3][4]={{1,0,0,0},{5,0,0,0},{9,0,0,0}};
int arr[3][4]={{1},{5,6}};——相当于
int arr[3][4]={{1},{5,6},{0}};
int arr[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};——相当于
int arr[][4]={1,2,3,4,5,6,7,8,9,10,11,12};
二维数组如果有初始化，行可以省略，列不可以省略
int arr[][4]={{0,0,3},{},{0,10}};——这样的写法是合法的
二维数组的使用
二维数组的使用也是通过下标的方式。
直接看代码吧
#include<stdio.h>
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]={0};
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;
}
通过结果我们可以分析到，其实二维数组在内存中也是连续存储的。
如果把二维数组的每一行看做一个一维数组，那么每一行的一维数组也有数组名
arr[0]就是第一行的数组名
arr[1]就是第二行的数组名
以此类推
数组越界
数组的下标是有范围限制的。
数组的下规定是从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1。
所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。
C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就 是正确的， 所以程序员写代码时，最好自己做越界的检查。
#include<stdio.h>
int main()
{
int arr[10]={1,2,3,4,5,6,7,8,9,10};
int i=0;
for(i=0;i<=10;i++)
{
printf("%d\n",arr[i]);
//当i等于10的时候，越界访问了
}
return 0;
}
这个程序虽然跑起来了，并且有输出结果，但是我们发现，最后的结果不是我们想要看到的，那么，这个就是数组的越界访问
所以，二维数组的行和列也可能存在越界。
数组的应用实例1：三子棋 这个内容我之前写过了的 三子棋——“C”_认真学习的小雅兰.的博客-CSDN博客
数组的应用实例2：扫雷 这个内容我之前也写过 扫雷——“C”_认真学习的小雅兰.的博客-CSDN博客
接下来的这个知识点呢，是为数组作为函数参数，小雅兰想把这个内容在下一篇博客中专门讲一下，因为，我们需要讲到一种算法——冒泡排序。
好啦，小雅兰今天的内容就到这里啦，今天也是努力的小菜兰呀！！！
