通过指针引用数组
数组元素的指针
数组指针:数组中的第一个元素的地址，也就是数组的首地址
指针数组:用来存放数组元素地址的数组（存放数组元素指针的变量），称之为指针数组。
eg：
//定义一个一维数组
int a[] = {1,4,9};
//使用指针变量存储数组的第一个元素的首地址，也就是数组的首地址
int *p = &a[0];
//在C语言中，由于数组名代表数组的首地址，因此，数组名实际上也是指针。
int *p = a;
注意:
虽然我们定义了一个指针变量接收了数组地址，但不能理解为指针变量指向了数组，而应该理解为指向了数组的元素。
指针的运算
指针运算：指针变量必须要指向数组的某个元素。
| 序号 | 指针运算 | 说明 |
| 1 | 自增：p++,++p,p = p+1|p +=1 | 让指针变量指向下一个元素 |
| 2 | 自减：p--,--p,p-=1 | 让指针变量指向上一个元素 |
| 3 | 加一个数：p + 1 | 下一个元素的(首)地址 |
| 4 | 减一个数：p - 1 | 上一个元素的(首)地址 |
| 5 | 指针相减：p1 - p2 | p1，p2之间相差几个元素 |
| 6 | 指针比较：p1<p2 | 前面的指针小于后面的指针 |
通过指针引用数组元素
案例一:
#include <stdio.h>
int main()
{
// 一般数组
int a[] = {1,3,5,7,9};
// 计算数组中元素的个数
// sizeof用法：sizeof(运算数) 或者 sizeof 运算数
int len = sizeof a / sizeof a[0];
// 创建指针变量
int *p = a;
// 创建循环变量
register int i = 0;
// 遍历
for(;i < len; i++)
{
printf("[1] %d ",a[i]); // 下标法
printf("[2] %d ",*(a+i));// 指针法，但是这种写法，需要注意，a+i无法修改数组，只读
printf("[3] %d ",*(p+i));// 指针法，这种更为灵活，可读可写，建议这种写法
// printf("%d\n",*p); // 等价于上面写法
// p++;
}
printf("\n");
return 0;
}案例二：
#include <stdio.h>
int main()
{
int a[] = {10,22,33,44,55,66,77,88};
int *p = a;// 等价于 int *p = &a[0] 元素：10
p++;// 指针+1，元素值不改变 元素：22
printf("%d\n",*p);// p = p + 1 元素：22
int x = *p++;// x = 22,p++ -- *p：33
printf("%d,%d\n",x,*p);// *p++：先*p,在p++, 元素：22,33
int y = *(++p);// ++p, y = 44;
printf("%d,%d\n",y,*p); // *(++p)：先p++,再*p，元素：44,44
(*p)++;// 元素值+1,指针不改变
printf("%d\n",*p);// index为3的元素值：44 + 1 = 45
return 0;
}数组名做函数参数
表现形式：
1. 形参和实参都用数组名
2. 实参用数组名，形参用指针变量
3. 实参形参都用指针变量
4. 实参为指针变量，形参为数组名
数组指针与指针数组
数组指针
数组指针：指向数组的指针变量。
数组指针定义:
假定该指针变量指向具有N个元素的一维数组，则数组指针变量定义如下:
数据类型(*数组指针变量名)[N];
一维数组:
int a[N] = {1,2,3};
int (*p)[N] = &a;二维数组:
int a[][N]={1,3,5,7};
int(*p)[N]= a[0];// &a[0][0]
特点：
1.先有数组，后有指针
2.它指向的是一个完整的数组
3.指针和数组中符号优先级： () > [] > *
分析：
int arr[3]= {1,2,3};
int *p= arr;// &arr[0] 首地址:第1个元素的首地址int(*p)[3]=&arr
// p = &arr[0];
int arr[][3]={1,2,3,4,5,6};
int *p = arr[0];// &arr[0][0]首地址:第1行第1列元素的首地址
int(*p)[3]=&arr[0];// p = &arr[0][0]
一维数组指针：
语法:
数据类型 (*指针变量名)[容量]；
eg：
/**
* 数组指针：指向数组的指针
*/
#include <stdio.h>
int main()
{
// 一维数组指针
// 先有数组，再有指针
int arr[3] = {100,200,300};
// 获取数组的元素个数
int len = sizeof arr / sizeof arr[0];
// 定义一个数组指针，指向arr数组
// 数组指针的语法：数据类型 (*指针变量名)[容量];
int (*p)[3] = &arr;// 此时p不是指向arr数组的第一个元素，而是指向arr这个数组本身
printf("%p\n",p);
// p++; 此时p++会跳出整个数组
// printf("%p\n",p);
printf("%d\n",(*p)[2]);// 300
// 遍历
for(int i = 0; i < len; i++)
{
printf("%d\n",(*p)[i]);
}
printf("\n");
// int *p = &arr[0] | arr;// 这种写法，代表p指向的不是数组本身，是数组中的第一个元素
}二维数组指针
语法：
数据类型 (*指针变量名)[容量]；
eg：
/**
* 二维数组指针案例
*/
#include <stdio.h>
int main()
{
// 数组指针：先有数组，再有指针
int arr[][3] = {{100,200,300},{1000,2000,3000},{10,20,30}};
// 创建一个数组指针，指向二维数组
// int (*p)[3] = &arr; // p[0] -->{100,200,300},p[1] -->{1000,2000,3000}，也就是说：
p[0] = 元素100的首地址，p[1] = 元素1000的首地址
int (*p)[3] = arr; // arr等价于&arr[0],p[0] = 元素100的首地址
// 获取元素100？
printf("100-%d\n",(*p)[0]);// arr[0][0]
// 获取元素2000?
printf("2000-%d,%d,%d\n",*(*(p+1)+1),*(p[1]+1),p[1][1]);
// arr[i][j] ===> *(*(p+i)+j)
===> *(p[i]+j) ===> p[i][j]
return 0;
}
指针数组
概念：是一个数组，数组中每一个元素都是一个指针。
特点：
1.先有指针，后有数组。
2.本质是一个数组，只是数组中的元素类型为指针。
语法：
数据类型 *数组名[容量]；
eg:
/**
* 指针数组
*/
#include <stdio.h>
int main()
{
// 定义三个变量
int a = 10, b = 20, c = 30;
// 定义指针数组，指针数组用来存放指针（变量或者常量的内存地址）
int *arr[3] = {&a,&b,&c};
// 获取数组的大小
int len = sizeof arr / sizeof arr[0];
// 遍历数组
for(int i = 0; i < len; i++)
{
printf("%3d",*(arr[i])); // 输出每个指针所指向的值，需要解引用
}
printf("\n");
return 0;
}
建议：我们一般使用指针数组处理字符串函数的传参
值传递：一般发生在函数形参的类型为char、short、int、long、float、double这样的类型，它的传递，一般是实参将自己的值复制一份给形参，也就是实参变量和形参变量的变量空间是分开的。此时形参无法改变实参的数据。
引用传递：一般发生在函数形参的类型为数组、指针这样的类型，它的传递，一般是实参将自己的内存首地址复制一份给形参，也就是实参变量和形参变量对应内存空间是同一个。此时形参可以改变实参的数据。
字符串指针
字符串实现
在C语言中，表示一个字符串有以下两种形式：
1. 用字符数组存放一个字符串
2. 用字符指针指向一个字符串
注意：字符数组和字符指针变量都能实现字符串的存储与运算。
字符数组和字符指针的联系
1.字符数组由元素组成，每个元素中存放一个字符，而字符指针变量中存放的是地址，也能作为函数参数。
2.只能对字符数组中的各个元素赋值，而不能用赋值语句对整个字符数组赋值。
3.字符数组名虽然代表地址，但数组名的值不能改变。因为数组名是常量。
4.对于字符串中字符的存取，可以用下标法，也可以用指针法。
eg：
/**
* 字符数组和字符指针的联系
*/
#include <stdio.h>
int main()
{
// 使用两种方式定义字符串
char str1[] = "你好，马杰克！";
char *str2 = "您好，马应龙！";
// 测试赋值
// str1 = "你好,龙瑞！"; // 不能对字符数组整体赋值，如果要赋值，请使用string.h中strcpy()
str2 = "你好,药可！";
// 打印输出
printf("%s\n%s\n",str1,str2);
char a[] = "I love you!";
char *b = "I love you!";
// 使用下标法和指针法访问字符串
printf("%c\n%c\n",a[4],*(b+4));// v v 空格也是占位的
return 0;
}字符串指针作为形式参数
1.实参与形参都可以是字符数组
2.实参用字符数组，形参用字符指针（在函数内部不能对字符串中的字符做修改）
3.实参和形参都是指针变量（在函数内部不能对字符串中的字符做修改）
4.实参是指针类型，形参是字符数组。
注意：
1.字符数组在创建的时候，会在内存中开辟内存空间，内存空间可以存放字符数据；字符指针在创建的时候，需要依赖于字符数组，字符指针在内存中开辟的内存空间中，存放的是数组元素的内存地址。字符指针的创建依赖于字符数组，字符数组可以独立存在，而字符指针不能独立存在。
2.字符数组可以初始化，但是不能赋值；字符指针可以初始化，也可以赋值。
函数指针与指针函数
函数指针
定义：函数指针本质是指针，它是函数的指针。(定义一个指针变量，变量中存储了函数的地址)函数都有一个入口地址，所谓指向函数的指针，就是指向函数的入口地址。这里函数名就代表入口地址。
函数指针存在的意义:
1.让函数多了一种调用方式
2.函数指针作为形参，可以形式调用(回调函数)
定义格式:
返回值类型(*变量名)(形式参数列表);
举例:
int (*p) (int a,int b);
函数指针的初始化
1. 定义同时赋值
// 得先有函数，才能定义这个函数的指针
int fun(int a,int b){..}
// 定义函数指针并给它赋值
int (*p) (int a,int b) = fun;// fun不能跟()2. 先定义后赋值
// 得先有函数，才能定义这个函数的指针
float fun(int a,double b,char c){..}
// 先定义函数指针
float (*p) (int a,double b,char c);
// 赋值
p = fun;总结:
1.函数指针指向的函数要和函数指针定义的返回值类型，形参列表对应，否则编译报错
2.函数指针是指针，但不能指针运算，如p++等，没有实际意义。
3.函数指针作为形参，可以形成回调。
4.函数指针作为形参，函数调用时的实参只能是与之对应的函数名，不能带小括号
5,函数指针的形参列表中的变量名可以省略。
指针函数
定义：本质是函数，这个函数的返回值类型是指针，这个函数称为指针函数
定义格式：
指针类型 函数名（形参列表）
{
函数体；
return 指针变量;
}
注意：
在函数中不要直接返回一个局部变量的地址，因为函数调用完毕后，局部变量会被回收，使得返回的地址就不明确，此时返回的指针就是野指针。
解决方案：
如果非要访问，可以给这个局部变量添加static，可以延长它的生命周期，从而避免野指针（尽量少用，因为存在内存泄漏）。
野指针，空指针
野指针
定义：
访问一个已经销毁或者访问受限的内存区域外的指针，这个指针就被称为野指针。
野指针产生的场景：
1.变量未初始化，通过指针访问该变量
2.指针变量未初始化
3.指针指向的内存空间被（free函数）回收了
4.指针函数中直接返回了局部变量的地址。
5.指针指向数组以外的地址（下标越界）
如何避免野指针：
写代码要养成两个习惯(通过编码规范避免)
1.指针变量幻及时初始化，如果暂时没有对应的值，建议赋值为NULL;
2.数组操作(遍历,指针运算)时，注意数组的长度，避免越界
3.指针指向的内存空问被回收，建议给这个指针变量赋值为NULL;
4.指针变量使用之前要检查它的有效性(以后开发中要做非空校验)
说明:NULL是空常量，它的值是0，这个NULL一般存放在内存中的0x00000000位置，这个地址只能存放NULL，不能被其他程序修改。
空指针
空指针，又被称作悬空指针:当一个指针的值是NULL，这个指针被称为空指针;对空指针访问会运行报错(段错误)
多重指针（二级指针）
定义：
二级指针，又被称作多重指针，引用一级指针的地址，此时这个指针变量就得定义成二级指针。
定义格式:
数据类型 **变量名 = 指针数组的数组名或者一级指针的地址
eg：
// 字符型指针数组
char *arr[3] = {"abc","aaa034","12a12"};// 等效于：char arr[3][6] = {"abc","aaa034","12a12"}
// 定义二级指针并赋值(指针需要跟依赖的源同类型)
char **p = arr;// 正确
int array[2][3] = {{1,2,3},{11,22,33}};
int **k = array;// 编译报错，数据类型不相符（二维数组不等于指针数组）
int a = 90;
int *p = &a;// 一级指针
int **k = &p;// 正确，二级指针结论：
1. 二级指针和指针数组是等效，和二维数组不等效
2. 二维数组和数组指针是等效，和二级指针不等效
二级指针的用法：
1. 如果是字符的二级指针，可以像遍历字符串数组一样遍历它
2. 如果是其他的二级指针，就需要解引用两次访问它所指向的数据
/**
* 二级指针案例：使用指向指针数据的指针变量。
*/
#include <stdio.h>
void fun1()
{
char *name[]={"Follow me","BASIC","Great Wall","FORTRAN","Computer design"};
// 定义一个二级指针
char **p;
// 定义循环变量
int i = 0;
// 遍历指针数组
do
{
p = name + i;
printf("%s\n",*p);
i++;
}while(i < 5);
printf("\n");
}
void fun2()
{
int arr1[5] = {11,12,13,14,15};
// 创建一个指针数组
int *arr[] = {&arr1[0],&arr1[1],&arr1[2],&arr1[3],&arr1[4]};
int **p = arr,i = 0;
// 遍历
for(;i < 5; i++)
{
// printf("%5d",**(p+i));
printf("%5d",**p);
p++;
}
printf("\n");
}
int main()
{
fun1();
fun2();
}
main函数的原型
main函数有多种定义格式，main也是函数，函数相关的结论对main函数也有效（也可以定义main函数的函数指针）
main函数的完整写法：
int main(int argc,char *argv[]){}
int main(int argc,char **argv){}
扩展写法：
int main(){}
int main(void){}
void main(){}
main(){} ---- int main(){}
void main(void){}
int main(int a){}
int main(int a,int b,int c){}
说明:
1.argc，argv是形参的名称，它们俩可以修改
2.main函数的扩展写法有些编译器不支持，编译报警告
3.argc和argv的常规写法:
"argc":存储了参数的个数
"argy":存储了所有参数的字符串形式
4.main函数是系统通过函数指针的回调形式调用的
注意:如果一个函数没有写返回值类型，这个函数的默认返回类型是int。
常量指针和指针常量
常量
分为字面量和只读常量，字面量（就是我们平时直接操作的如：printf（12）|printf（“hello”））；只读常量使用关键字const修饰，凡是被这个关键字修饰的变量，一旦赋值，值就不能改变。
语法：
//字面量举例，字面量是一种匿名的常量
printf(12);
printf("请输入一个数:\n”);
// 只读常量
const int a= 18;
a = 21://编译错误，因为此时这个变量是只读常量，所以不可史改其伯常量指针
定义:常量的指针，本质是一个指针，指针指向的数据不能改变.
定义格式:
const 数据类型 *变量名;
结论:
1.常量指针指向的数据不能被改变(不能解引用间接修改数据)
2.常量指针的地址可以改变
应用场景：作为形式参数，实际参数需要给一个常量。
案例：
#include <stdio.h>
/* 常量指针 */
void test1()
{
// 定义变量
int a = 10;
// 定义常量指针
const int *p = &a;
// *p = 100; // 编译报错，常量的值不能修改（常量指针指向地址空间的数值不能修改）
printf("%d\n",*p);// 10
int b = 90;
p = &b; // 编译通过，常量的地址可以修改（常量指针指向的地址空间可以发生改变）
printf("%d\n",*p);// 90
}
int main()
{
test1();
}指针常量
定义：指针的常量，指针的指向不能改变
定义格式：
数据类型* const 变量名；
举例：
int* const p; // 指针常量
结论：
1. 指针常量的指向不能被改变（不能给指针变量重新赋地址值）
2. 指针常量指向的数据可以改变。
注意：指针常量在定义时就要赋值；不能先定义后赋值，否则编译报错。
常量指针常量
定义语法：
const 数据类型* const 变量名;
举例：
const int* const p; // 常量指针常量
作用：p的指向不能被改动（地址），p指向的数据不能被改（地址对应内存中存放的数据）
动态内存分配
我们要想实现动态内存分配，就需要学习标准C提供的函数库：
1. 函数所属的库文件
2. 函数的原型-函数的声明
a. 函数名
b. 形参
c. 返回值类型
3. 函数的功能
注意：内存分配函数在申请内存时，建议用多少申请多少，可以有少量的预留量；但不能越界访问（虽然编译和运行不报错，但数据不安全）
常用函数
malloc
头文件：#include <stdlib.h>
函数功能：C 库函数void *malloc(size_t size)分配所需的内存空间，并返回一个指向它的指针。
函数原型：
函数名：malloc
形式参数：size_t size：内存块的大小，以字节为单位。本质上就是一个unsigned int
返回值类型：void* ：该函数返回一个指针，指向已分配大小的内存，如果请求失败，返回NULL。
举例：
int *p = (int*)malloc(4);
说明：
1. malloc函数分配的内存没有默认值，是不确定数，大概率是0；
2. malloc函数申请的内存空间连续。
calloc
头文件:minclude <stdlib.h>
函数功能:C库函数 void*calloc(size_t nitems,size_t size)分配所需的内存空间，并返回一个指向它的指针
mallec和calloc之间不同的是，malloc不会设置内存为零，而callec会设置内存为零。
函数原型:void *calloc(size_t nitems,size_t size)
函数名:calloc
形式参数:
size_t nitems:申请多少个
size_t size:一个占几个内存单元(一个内存单元 等于 一个字节)返回值类型:void*:该函数返回一个指针，指向己分配大小的内存。如果请求失败，返回NULL。
举例：
int *p = (int*)calloc(3,4); // p指向的空间的大小是12个字节 if(!p) printf("内存申请失败！\n");说明：
1. calloc函数分配的内存有默认值，每个内存单元都是0
2. calloc函数申请的内存空间连续
3. calloc大多时候为数组中的元素申请内存
转存栈中数组中的数据：
int arr[3] = {10,20,30}; // 在栈区 int *p = (int*)calloc(3,4); // 申请内存，在堆区 if(!p) puts("内存申请失败！"); // 转存 for(int i = 0;i 3; i++) p[i] = arr[i]; // 遍历 for(int i = 0;i 3; i++) printf("%d,",p[i]); printf("\n"); // p使用完，记得释放内存 free(p); p = NULL; // 内存回收后，建议置空
realloc
头文件：#include
函数功能：尝试重新调整之前调用malloc或calloc所分配的ptr所指向的内存块的大小。
函数原型：void *realloc(void *ptr,size_t size)
函数名：realloc
形式参数：
void *ptr：是malloc或者calloc的返回值
size_t size：重新分配后的内存大小
返回值：void*：该函数返回一个指针，指向已分配大小的内存。如果请求失败，返回NULL。
案例：
int *p = (int*)malloc(4); int *w = (int*)realloc(p,20); // int *q = (int*)realloc(p,0); // 等效于free(p)说明：
1. realloc以原来malloc返回的内存地址开始，分配总共20个字节的内存空间
2. 如果原来的内存空间后有20个连续空间，就扩容20-4 =16个内存单元，返回原来旧的内存首地址。
3. 如果原来的内存空间后不够20个连续内存空间，就重新找一个内存地址开始，申请20个内存单元。并将原来的数据拷贝到新的内存中，回收旧的内存单元，并返回新的内存首地址。
free
头文件：#include
函数功能：释放之前调用 malloc、calloc、realloc所分配的内存空间，是访问完记得使用NULL置空。
函数原型：void free(void *ptr)
函数名：free
形式参数：
void *ptr：calloc,malloc.realloc的返回值
返回值类型：void：没有返回值
注意：
1. 堆内存中的指针才需要回收，栈中系统会自动回收
2. 堆内存不能重复回收，运行会报错
说明：
1. 堆的内存空间相比较栈要大很多
2. 内存分配函数返回的指针变量可以参与运算（只读），但不能被修改（p++或者p+=i 是错误的）
扩展：形式参数和实际参数的对应关系
//形式参数和实际参数的对应关系
#include <stdio.h>
//void test(int arr[2][3]) //可以
//void test(int arr[][3]) //可以
//void test(int arr[2][]) //不可以
//void test(int arr[][]) //不可以
//void test(int (*arr)[]) //可以
//void test(int(*)arr[]) //语法错误
//void test(int(*arr)[3])
//void test(int *arr[]) //不可以
//----------------------------------------
//void test2(int *arr[]) //可以
//void test2(int arr[][1]) //不可以
//void test2(int **arr) //可以
void test2(int(*arr)[]) //不可以
{
printf("test\n");
}
int main()
{
/*
int arr[2][3] = {0};
test(arr);
*/
/*
int a = 20;
int *arr[] = {&a};
test2(arr);
*/
int** p;
test3(p);
return 0;
}
void和void*
定义:
void:是空类型，是数据类型的一种
void*:是指针类型，是指针类型的一种，可以匹配任意类型的指针，类似于通配符
void
说明:void作为返回值类型使用，表示没有返回值;作为形参，表示形参列表为空，在调用函数是不能给实参.
举例:
// 函数声明
void fun(void);// 等效于 void fun();
// 函数调用
fun();
void*
说明:
void*是一个指针类型，但该指针的数据类型不明确，无法通过解引用获取 内存中的数据，因为 void* 不知道访问几个内存单元。
void*是一种数据类型，可以作为函数返回值类型，也可以作为形参类型
void*类型的变量在使用之前必须强制类型转换，明确它能够访问几个字节的内存空间
int *p = (int*)malloc(4); double *p2 = (double*)malloc(8);
举例：
#include <stdio.h>
#include <stdlib.h>
// 函数定义
void* fun(void* p) // 指针函数（返回值类型是指针的函数，此时返回的是不明确类型，需要外部强转）
{
int *p;
// double *p;
// long *p;
// char *p;
return p;
}
// 函数调用
void main()
{
int *p;
void* a = fun(p);// 这种接收方式，实际上没有意义
printf("%p\n",a);// 可以正常打印，打印出一个地址
*a = 10;// 编译报错，void*变量不能解引用访问数据
int *w = (int*)a;
*w = 10;// 编译和运行正常，void*变量a在使用前已经强制类型转换了，数据类型明确了，访问的内存
单元明确了。
}说明:
void*作为返回值类型:这个函数可以返回任意类型(char*,int*,double*等 )的指针。
void*作为形参类型:这个函数在调用时，可以给任意类型( char*,int*,double*等 )的指针
总结:
void*类似于通配符，不能对void*类型的变量解引用(因为不明确内存单元的大小)
void*在间接访问（解引用）前要强制类型转换，但不能太随意