目录
数组 一维数组
某一数据类型的变量的集合，位于一块连续的内存上
1、功能：
方便地定义相同数据类型的变量
整数数[30]；
相当于：
整数 num1；
整数 num2;
。 。 。
整数 num30；
2、数组框架：
元素的数据类型变量名[元素数量]；
元素的数据类型： 基本数据类型：int char float。 。 。
此外：int *、char *、...
元素数量：正整数
3.如何定义数组：
(1) int a[3]; //未初始化的定义，定义了一个有3个元素的数组。 数组的元素类型为：int，数组的成员值为随机值。
(2) int a[3]={1,2,3}； //所有初始化定义都定义了一个包含 3 个元素的数组。 数组的元素类型为：int，数组的成员值为
a[0] == 1、a[1] == 2、a[2] == 3
(3) int a[3]={1,2}； //部分初始化定义定义了一个包含3个元素的数组。 数组的元素类型为：int，数组的成员值为
a[0] == 1，a[1] == 2，a[2] == 0
(4) int a[]={1,2,3,4,5}; //不定长数组，必须初始化，定义一个有5个元素的数组，数组的元素类型为：int，数组成员值为
a[0] == 1、a[1] == 2、a[2] == 3、a[3] == 4、a[4] == 5
(5)
整数；
scanf("%d", #);
int a[数字]; //变长数组无法初始化。 定义时，必须确定num的值。 定义了一个包含 num 个元素的数组。 数组的元素类型为：int；
如果要给数组赋值，需要一一赋值。
4.计算数组内存大小：
数组内存大小==数组元素类型占用的字节数*元素数量
int a[5]={1,2,3,4,5};
(a) == (int)*5 == 4*5 ==20
5. 访问数组元素：
int a[5]={1,2,3,4,5};
a[0] == 1 第一个元素的地址 &a[0] == &(a[0])
a[1] == 2 第二个元素的地址 &a[1] == &(a[1])
a[2] == 3第三个元素的地址&a[2] == &(a[2])
a[3] == 4第四个元素的地址&a[3] == &(a[3])
a[4] == 5第五个元素的地址&a[4] == &(a[4])
访问数组元素的下标：0~（数组元素个数 - 1）
6、数组名称和数组数据类型的问题：
数组名是数组第一个元素的地址
int a[5] = {1,2,3,4,5};
a==&a[0]
//去掉变量名，剩下的就是它的数据类型
整数a[5]； 其数据类型为：int()[5]
字符a[4]； 其数据类型为：char()[4]
数据类型+变量名
整数a; 它的数据类型是：int
=================================================== =======================
学习数组后需要掌握的知识点：
1. 定义数组
2.给数组赋值
3.正确输出数组数据
4.数组的大小
5.数组的内存映射
=================================================== =======================
二维数组1本质上是一个一维数组
元素数据类型为一维数组的数组称为二维数组。
int a[2][3]； ==>int(a[2])[3];
2. 二维数组定义模型
小数组的元素类型变量名[N][M]；
N --> 大数组的元素数量。 大数组就是指这个二维数组。
M --> 小数组的元素数量。 小数组是指二维数组的元素。
小数组的元素类型——“int、char、float...
3.二维数组的定义与初始化
(1) int a[2][3]； //未初始化的定义，定义了一个二维数组。 该数组有两个元素。 元素类型为：int()[3]，其值为随机值。
(2) int a[2][3]={{1, 2, 3}, {4, 5, 6}}; //所有初始化定义都定义了一个包含两个元素的二维数组。 元素类型为：int()[3]，其值：
a[0][0]==1、a[0][1]==2、a[0][2]==3、a[1][0]==4、a[1][1 ]==5，a[1][2]==6
(3) int a[2][3]={1,2,3,4,5,6}; //所有初始化定义都定义了一个包含两个元素的二维数组。 元素类型为：int()[3]，其值：
a[0][0]==1、a[0][1]==2、a[0][2]==3、a[1][0]==4、a[1][1 ]==5，a[1][2]==6
(4) int a[2][3]={{1}, {4, 5}}; //部分初始化定义定义了一个包含两个元素的二维数组。 元素类型为：int ( )[3]，其值：
a[0][0]==1、a[0][1]==0、a[0][2]==0、a[1][0]==4、a[1][1 ]==5，a[1][2]==0
(5) int a[2][3]={1,2,3}； //部分初始化定义定义了一个包含两个元素的二维数组。 元素类型为： int ()[3] ，其值：
a[0][0]==1、a[0][1]==2、a[0][2]==3、a[1][0]==0、a[1][1 ]==0，a[1][2]==0
(6) int a[][3]={{1,2,3},{4}}; //变长二维数组定义了一个二维数组。 数组有两个元素，元素类型为：int()[3] 二维数组定义了一个二维数组。 该数组有两个元素。 元素类型为：int()[3]。 其值为：
a[0][0]==1、a[0][1]==2、a[0][2]==3、a[1][0]==4、a[1][1 ]==0，a[1][2]==0
int a[2][]={{1, 2, 3},{4}};//必须确定小数组的元素个数，否则编译会报错
4. 二维数组的大小
二维数组的大小==小数组的元素类型大小*小数组的元素个数*大数组的元素个数==大数组的元素个数*数据类型小数组的大小
int a[2][3]；
(a) == (int)*2*3 == 4*2*3 == 24
5. 访问数组元素
int a[2][3]； //这种数组称为两行三列数组。
a[0][0]==1,--》元素地址为：&a[0][0]
a[0][1]==2,--》元素地址为：&a[0][1]
a[0][2]==3,--》元素地址为：&a[0][2]
a[1][0]==4,--》元素地址为：&a[1][0]
a[1][1]==5,--》元素地址为：&a[1][1]
a[1][2]==6,--》元素地址为：&a[1][2]
指针数组1.概念：
它本质上是一个一维数组，其元素类型是指针。
2. 定义模型
整数a;
整数b；
整数c;
整数d;
int *p1 = &a;
int *p2 = &b;
int *p3 = &c;
int *p4 = &d;
(int *) a[4]; ==> int *arry[4]; //定义一个4个元素的数组，元素类型为：int *
//arry[0] 的类型为：int *
//&arry[0] 类型为：int **
arry[0] = &a;
arry[1] = &b;
arry[2] = &c;
arry[3] = &d;
=================================================== =======================
指针一级指针1.概念：
指针也是变量的一种类型。 指针变量用于存储相应变量的内存地址。
2.如何定义指针变量
Model：存储变量的数据类型*变量名
int a;//定义一个整型变量
a = 100； //将100转换成二进制存入整型变量a中
整数*p； //定义了一个整型指针变量，准备存放整型变量的内存地址。
p = &a; //获取变量a的地址并将其存储到指针变量p中
3.如何使用指针变量（解引用、获取目标）
整数a=100；
int *p=&a;
*p = 200； //通过指针变量访问，存储内存地址数据
//int *p=&a;
相当于
整数*p；
p=&a;
不等于：
整数*p；
*p=&a；
4、指针内存大小：
32位系统占用4字节
64位系统占用8个字节
5.指针加减-->内存地址加减
整数a=100；
int *p=&a;
假设 p 的值为：
p==
综上所述：
p+1 == +(int) ==
字符b=100；
字符 *b_p=&b;
综上所述：
b_p+1 == b_p+1*(字符)
长长c=100；
长长 *c_p=&c;
综上所述：
c_p+1 == c_p+1*(长长)
总结：
整数指针+1 == 整数指针+1*(int)
字符指针+1 == 字符指针+1*(字符)
字符指针+2 == 字符指针+2*(字符)
long long 指针+2 == long long 指针+2*(long long)
注意：
指针加减要考虑其存储的对象的大小。
在添加或减少内存地址时，还必须考虑其存储的对象的大小。
内存地址由两部分组成：地址值和存储的对象。
6.指针变量数据类型问题
整数a=200； a的数据类型是：int
200的类型是：int
&a的类型为：int *
int arry[3]; 该数组的数据类型为：int()[3]
&arry 的类型为：int (*)[3]
int *p=&a; p的数据类型为：int *，存储对象的类型为：int
&p的类型为：int **，存储的对象的类型为：int *
&a的类型为：int *，存储的对象类型为：int
7. 万能指针（ point）
void *p //通用指针（），可以合法存储任何类型的变量地址，但存储后类型会变成void *。
void * 指针，无存储对象
整数a;
无效 *p = &a;
注意：要取消引用通用指针，必须首先强制转换类型
8. NULL --> 空指针
指针的零值：
# 空（无效*）0x0
整数*p； //p 包含一个随机值。 这种指针也称为野指针。 野指针是非常危险的，所以如果指针定义后没有初始化，就给它赋值NULL，这样比较安全。
int *p = NULL;
*p = 100；
取消引用 NULL 指针将导致段错误：
gec@:/mnt/hgfs/C语言/05/code$ ./a.out
故障（核心）-->分段故障（未经访问权限非法访问内存）
=================================================== =======================
二级指针1.概念：
指针变量用于存储可变的内存地址
一级指针存储的是指针变量以外的变量的地址。
辅助指针存储主指针变量的地址
2. 定义模型
一级指针变量类型*变量名；
字符*p；
字符 **q = &p;
int *p1;
int **q1 =&p1;
3、辅助指针的大小：
32位系统占用4字节
64位系统占用8个字节
int **q;
4==(q)
4.辅助指针数据类型问题
int **q; q 的数据类型为：-->int **
&q 的类型为：-->int ***
整数*p； p -->int *
&p -->int **
整数a； 一个-->整数
&a -->int *
=================================================== =======================
数组指针1.概念：
它本质上是一个一级指针，用于存储数组的地址。
整数a[2]； //其类型为：int()[2]
//&a的类型是：int (*)[2]
定义对应类型的指针变量来合法存储数组地址
int (*p)[2] = &a;
整数a; //它的类型是：int
//&a的类型是：int *
int *p = &a;
2. 定义模型：
字符a[10]； //其类型为：char()[10]
//&a的类型为：char(*)[10]
字符 (*p)[10] = &a;
整数a[2]； //它的类型是：int()[2]不等于int()[10]
//&a的类型是：int (*)[2]
定义对应类型的指针变量来合法存储数组地址
int (*p)[2] = &a;
int (*p1)[10] = &a; //非法存储
int a[2][3]； //其类型为：int()[2][3]
//&a的类型为：int (*)[2][3]
int (*p)[2][3] = &a
模型：
数组数据类型*变量名
3、内存大小：
32位系统占用4字节
64位系统占用8个字节
