05C语言——数组
一、基本概念
- 逻辑：一次性定义多个相同类型的变量，并存储到一片连续的内存中
- 语法释义：
int buf[5];- buf是数组名，即这片连续内存的名称
- [5] 代表这片连续内存总共分成5个相等的格子，每个格子称为数组的元素
- int 代表每个元素的类型，可以是任意基本类型，也可以是组合类型，甚至可以是数组初始化：在定义的时候赋值，称为初始化
int buf[5] = {100,200,300,400,500}; // ok，正常初始化 
- 示例代码：
#include <stdio.h>
int main(int argc, char const *argv[])
{
// (1)、一次性定义多个相同类型的变量
// a、以往的写法：
int num1 = 100;
int num2 = 200;
int num3 = 300;
// b、现有的写法：
int num[100]; // 想象中的：100 int num;
num[0]; // 如何表示数组的元素(从0开始到100-1)
// ...
num[99];
// (2)、 存储到一片连续的内存中
// 1、num1、num2、num3其实他们三个变量的内存也是连续存储的(如何证明：打印其地址即可)
printf("num1的地址 == %p\n", &num1); // &符号是取变量的地址的意思
printf("num2的地址 == %p\n", &num2);
printf("num3的地址 == %p\n", &num3);
/*
地址分析：
num1的地址 == 0x7ffc85bc4294
num2的地址 == 0x7ffc85bc4298
num3的地址 == 0x7ffc85bc429c
说明：1个地址 == 1个字节，所以以上三个变量是相邻的
*/
// 2、数组在内存中的说明
int buf[5] = {100, 200, 300, 400, 500};
// A、数组的元素在一片连续的内存中
printf("buf[0]内存的值 == %d, buf[0]的地址 == %p\n", buf[0], &buf[0]);
// printf("buf[0]+1的地址 == %p\n", &buf[0]+1);
printf("buf[1]内存的值 == %d, buf[1]的地址 == %p\n", buf[1], &buf[1]);
printf("buf[2]内存的值 == %d, buf[2]的地址 == %p\n", buf[2], &buf[2]);
printf("buf[3]内存的值 == %d, buf[3]的地址 == %p\n", buf[3], &buf[3]);
printf("buf[4]内存的值 == %d, buf[4]的地址 == %p\n", buf[4], &buf[4]);
/*
内存值、地址解析：
buf[0]内存的值 == 100, buf[0]的地址 == 0x7fff52e71d80
buf[1]内存的值 == 200, buf[1]的地址 == 0x7fff52e71d84
buf[2]内存的值 == 300, buf[2]的地址 == 0x7fff52e71d88
buf[3]内存的值 == 400, buf[3]的地址 == 0x7fff52e71d8c
buf[4]内存的值 == 500, buf[4]的地址 == 0x7fff52e71d90
每个数组元素(int型)，相隔4个地址，也就是4个字节，所以可以证明
数组里面的元素的内存都是相邻的(也就是数组是一片连续的内存构成的)
*/
// B、buf是数组名，即这片连续内存的名称(也表示数组首元素的地址)
// a、buf代表的地址
printf("buf代表的地址 == %p\n", buf);
// b、buf的作用范围(如何求一个地址的作用范围？？？让其+1，并将其和原先的地址进行比较即可)
printf("buf+1代表的地址 == %p\n", buf+1);
/*
解析：
buf代表的地址： 0x7fff52e71d80
buf+1代表的地址: 0x7fff52e71d84
所以可以得出buf的作用范围是4个字节，它和&buf[0]是相等的
*/
// c、&buf的作用范围
printf("&buf代表的地址 == %p\n", &buf);
printf("&buf+1代表的地址 == %p\n", &buf+1);
/*
解析：
buf代表的地址： 0x7fff52e71d80
buf+1代表的地址: 0x7fff52e71d94
所以可以得出&buf代表的作用范围是20个字节(刚好就是整个数组的大小)
*/
// (3)、数组的初始化：
int buf1[5] = {100, 200, 300, 400, 500}; // ok，正常初始化
// int buf2[5] = {100, 200, 300, 400, 500, 600}; // 不ok，越界了(会报一个警告： warning: excess elements in array initializer)
int buf3[5] = {100,200,300}; // ok，只初始化数组元素的一部分
int buf4[] = {100,200,300}; // ok，自动根据初始化列表分配数组元素个数
return 0;
}
二、数组元素的赋值和引用
- 存储模式：一片连续的内存，按数据类型分割成若干相同大小的格子
- 元素下标：数组开头位置的偏移量，a[0]引用第1个格子，a[1]引用第2个格子，以此类推
- 元素下标偏移量
- 示例代码：
#include <stdio.h>
// 计算数组元素的个数
#define CAL_ARR_NUM(A) (sizeof(A)/sizeof(A[0]))
// 整个数组的大小 / 数组的首元素的大小 == 数组元素个数
// 主函数
int main(int argc, char const *argv[])
{
// 初始化
int buf1[5] = {1,2,3,4,5}; // int型数组的12345，和char型数组(字符串)的"12345"是不一样的
char buf2[5] = {'1','2','3','4','\0'}; // 等价于 char buf2[5] = "1234";
// (1)、单个赋值
buf1[0] = 100;
buf1[1] = 200;
buf1[2] = 300;
buf1[3] = 400;
buf1[4] = 500;
// buf1[5] = 600; // 到此为止，后面的内存是非法区域(也就是你没有权限对其进行操作)
printf("buf[5] == %d\n", buf1[5]);
// (2)、循环赋值
unsigned long int ret = CAL_ARR_NUM(buf2);
printf("数组buf2的元素个数 == %lu\n", ret);
for (int i = 0; i < ret; i++)
{
buf2[i] = 'A'+i;
printf("buf2[%d] == %c\n", i, buf2[i]);
}
return 0;
}
三、其它类型的数组
(1)、多维数组
- 概念：若数组元素类型也是数组，则该数组称为多维数组
- 语法：
int buf[2][3]; // 相当于int [3] buf[2];
- 示例代码：
#include <stdio.h>
int main(int argc, char const *argv[])
{
// 一、二维数组
int buf[2][3] = {{1,2,3},{4,5,6}};
// (1)、二维数组各个地址的表示说明(推导)
// 1、&buf的作用范围
printf("\n");
printf("&buf代表的地址 == %p\n", &buf);
printf("&buf+1代表的地址 == %p\n", &buf+1);
/*
解析(本地址和后面的地址不相干，是之前编译分配的地址)：
&buf代表的地址 == 0x7fff037540c0
&buf+1代表的地址 == 0x7fff037540d8
说明：c到d == 16， 0到8 == 8， 总：24字节
*/
// 2、buf的作用范围
printf("\n");
printf("buf代表的地址 == %p\n", buf);
printf("buf+1代表的地址 == %p\n", buf+1);
printf("\n");
printf("&buf[0]代表的地址 == %p\n", &buf[0]);
printf("&buf[0]+1代表的地址 == %p\n", &buf[0]+1);
/*
解析(本地址和后面的地址不相干，是之前编译分配的地址)：
buf代表的地址 == 0x7fff24d28480
buf+1代表的地址 == 0x7fff24d2848c
&buf[0]代表的地址 == 0x7fff24d28480
&buf[0]+1代表的地址 == 0x7fff24d2848c
说明：0到c == 12， 总：12字节
*/
// 3、buf[0]的作用范围
printf("\n");
printf("buf[0]代表的地址 == %p\n", buf[0]);
printf("buf[0]+1代表的地址 == %p\n", buf[0]+1);
printf("\n");
printf("&buf[0][0]代表的地址 == %p\n", &buf[0][0]);
printf("&buf[0][0]+1代表的地址 == %p\n", &buf[0][0]+1);
/*
解析(本地址和后面的地址不相干，是之前编译分配的地址)：
buf[0]代表的地址 == 0x7ffc5d50d2f0
buf[0]+1代表的地址 == 0x7ffc5d50d2f4
&buf[0][0]代表的地址 == 0x7ffc5d50d2f0
&buf[0][0]+1代表的地址 == 0x7ffc5d50d2f4
说明：0到4 == 4， 总：4字节
*/
// 4、buf[1]的作用范围
printf("\n");
printf("buf[1]代表的地址 == %p\n", buf[1]);
printf("buf[1]+1代表的地址 == %p\n", buf[1]+1);
/*
解析(本地址和后面的地址不相干，是之前编译分配的地址)：
buf[1]代表的地址 == 0x7ffc8c006c2c
buf[1]+1代表的地址 == 0x7ffc8c006c30
说明：2c到30 == 4， 总：4字节
*/
return 0;
}(2)、字符数组
- 概念：专门存放字符的数组，称为字符数组
- 示例代码：
#include <stdio.h>
int main(int argc, char const *argv[])
{
// 二、字符数组
// (1)、字符串数组的初始化
char s1[5] = {'a', 'b', 'c', 'd', 'e'}; // 字符数组，不是字符串(末尾没有'\0')(字符串是一个特殊的字符数组)
char s2[5] = {'a', 'b', 'c', 'd', '\0'}; // 它既是字符数组，又是字符串
char s3[5] = {"nihao"}; // 字符数组(末尾没有'\0')
// printf("%s\n", s3); // 此处因为没有'\0'，有可能打印不出数据来
char s4[5] = {"niha"}; // 字符串(末尾有'\0')
char s5[5] = "niha"; // 字符串的简写
// (2)、字符串数组的赋值和引用
// a、字符数组的赋值和引用和前面的普通数组的赋值一样(为什么？因为char型本质上就是单字节的int整型)
// b、字符串的赋值，可以使用字符串处理函数(str开头的函数)
// 栈区(可读可写) 常量区(可读不可写)
char s6[256] = "多姿多彩"; // 初始化
printf("s6 == %s\n", s6);
// 使用strcpy函数对字符串数组进行赋值
bzero(s6, sizeof(s6)); // 将s6数组清零(清sizeof(s6)这么大的空间)
// 将常量区的数据，复制到栈区中(s6)，后面修改s6的值，修改是栈区s6的值
strcpy(s6, "多姿多彩");
printf("s6 == %s\n", s6);
//问题：
// 栈区(可读可写) 常量区(可读不可写)
char *s7 = "nihao，shijie";
// 将常量区("nihao...")的数据，通过s7指针复制到另一个常量区""nihao.."
// strcpy(s7, "hello world"); // Segmentation fault (core dumped)
return 0;
}四、数组语法解析
- 任意的数组，不管有多复杂，其定义都由两部分组成。
- 第1部分：说明元素的类型(type)，可以是任意的类型（除了函数）
- 第2部分：说明数组名(x)和元素个数(N)
- 示例代码：
int a[4]; // 第一部分：int(元素的类型)， 第二部分：a[4](数组名+元素个数)
int b[3][4]: // 第一部分：int [4](元素的类型)， 第二部分：b[3](数组名+元素个数)
int c[2][3][4]; // 第一部分：int [3][4](元素的类型)， 第二部分：c[2](数组名+元素个数)
int *d[6]; // 第一部分：int *(元素的类型)， 第二部分：d[6](数组名+元素个数)
int (*e[7])(int,char); // 第一部分：int (*)(int,char)(元素的类型)， 第二部分：e[7](数组名+元素个数)至此，希望看完这篇文章的你有所收获，我是Bardb，译音八分贝，期待下期与你相见！