目录
一、字符指针
二、指针数组
三、数组指针
1、数组指针的定义
2、&数组名和数组名的区别
3、数组指针的使用
四、数组传参和指针传参
1、一维数组传参
2、一级指针传参
3、二维数组传参
4、二级指针传参
五、函数指针
1、函数指针的定义
2、函数指针的使用
六、函数指针数组
1、函数指针数组的定义
2、函数指针数组的用途
七、指向函数指针数组的指针
1、定义
八、回调函数
九、总结
一、字符指针
字符变量的地址用字符指针接收
int main()
{
char ch = 'x';
//ptr前的*是在告诉我们ptr是指针
char* ptr = &ch;//字符变量的地址用字符指针ptr接收
}还有另外一种使用方式
#include <stdio.h>
int main()
{
//常量字符串不能被修改，用const修饰
const char* ptr = "happy new year";
printf("%s\n", ptr);
return 0;
}这串代码很容易认为是把字符串"happy new year"放到字符指针ptr里了，但本质是把字符串“happy new year”的首字母h的地址放到了ptr中。
剑指offer例题
#include <stdio.h>
int main()
{
char a[] = "hello";
char b[] = "hello";
const char* c = "hello";
const char* d = "hello";
if (a == b)
printf("a和b相同\n");
else
printf("a和b不相同\n");
if (c == d)
printf("c和d相同\n");
else
printf("c和d不同\n");
return 0;
}【程序运行结果】
为什么是以上的结果呢？
不同的数组在创建时，会在内存中开辟不同的空间。由于地址不同，则a和b不相同。
因为常量字符串永远都不会被改变掉，所以它在内存中就没必要再开辟一个空间来存放另一个hello，所以c和d会同时指向字符串的首地址。
二、指针数组
int* arr[10];
char* arr[10];指针数组本质上就是数组，是一个存放指针的数组(或存放地址的数组)
详细内容请看《初阶指针》 点击跳转
三、数组指针
1、数组指针的定义
数组指针本质上是指针，是能够指向数组的指针。
int *p[10];
解释：
优先级 * < [],所以p指向的是数组，并且每一个元素的类型都是int*，
所以它是一个指针数组
int (*p)[10];
解释：
由于加了括号，p先和*结合，这说明了p是一个指针，然后指向一个大小
为10的数组，并且每一个元素都是int类型，所以它是一个数组指针2、&数组名和数组名的区别
这块内容在《深入学习数组》已经讲过了 点击跳转
这里再为大家说说它们的区别
对于下面的数组
int arr[10];我们都知道arr是数组名，数组名表示数组首元素的地址。
那&arr是什么意思，我们分别打印出它们的地址
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
printf("arr：%p\n", arr);
printf("&arr:%p\n", &arr);
return 0;
}【程序运行结果】
可见它们的地址都是一样的，难道它们真的是一样的吗？我们再来看一段代码
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
printf("arr：%p\n", arr);
printf("arr：%p\n", arr + 1);
printf("&arr:%p\n", &arr);
printf("&arr:%p\n", &arr + 1);
return 0;
}【程序运行结果】
根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义却不一样。
实际上：&arr是的是数组的地址(整个数组)，而不是数组首元素的地址。&arr + 1，跳过的是整个数组的大小。
&arr的类型是
,是一种数组指针类型
3、数组指针的使用
一般用于二维数组
例：用一个数组指针打印一个二维数组
#include <stdio.h>
//二维数组传参arr[][3]、arr[3][3]
void Print(int(*p)[3], int row, int col) //二维数组arr是第一行数组的地址，
//也就是一个一维数组的地址
{
for (int i = 0; i < row; i++)
{
for (int j = 0; j < col; j++)
{
printf("%d ", p[i][j]);
}
printf("\n");
}
}
int main()
{
int arr[3][3] = { {1,2,3},{4,5,6},{7,8,9} };
//封装一个数组来打印
Print(arr, 3, 3);
return 0;
}【程序运行结果】
最后再看看下面这几行代码的意思
int arr[5]; //整型数组，数组有5个元素
int* p[10]; //是指针数组，数组有10个元素，每个元素的类型是int*
int(*p)[10]; //数组指针，指向10个元素的数组，每个元素是int类型
int(*p[10])[5]; //这个要拆开看，p先和[]结合，是一个数组有5个元素，
//并且它的类型是int(*)[5] (把p[10]去掉就是其类型)四、数组传参和指针传参
在写代码的时候难免要把【函数】或者【指针】传给数组，那函数的参数改如何设计呢？一起来看吧
1、一维数组传参
//一维数组传参的形参可以这么写
void test(int arr[])
void test(int arr[10])
void test(int* arr) //arr是数组首元素的地址，用指针接收
int main()
{
int arr[10] = { 0 };
//函数传参传参
test(arr);
return 0;
}2、一级指针传参
//一级指针传参
void test(int *arr[10])//一级指针接收，大小也可省略不写
void test(int **arr) //arr是首元素地址，数组每一个元素类型都是int*
//一级指针传参可以拿二级指针接收
int main()
{
int* arr[10] = { 0 };
test(arr);
return 0;
}3、二维数组传参
void test(int arr[3][3])
void test(int arr[][4])//行可省，列不可省
void test(int (*p)[3]) //二维数组arr是第一行的地址
//第一行的地址就是整个一维数组的地址，所以用数组指针接收
int main()
{
int arr[3][3] = { 0 };
test(arr);
return 0;
}4、二级指针传参
思考：函数的参数为二级指针，实参可以是什么？？
void test(int** p)
{
;
}
int main()
{
int** p;
test(p);//二级指针传参，二级指针接收
int* p;
test(&p);//一级指针地址传参，二级指针接收
int* arr[10];
test(arr);//arr作为首元素地址，每个元素都是int*类型，二级指针接收
return 0;
}五、函数指针
1、函数指针的定义
函数指针的本质上也是个指针，它是指向函数的指针。
这可以类比数组指针（指向数组的指针）
int arr[10];
int (*p)[10] = &arr;我们也能不能&函数名，拿到函数的地址呢？然后再把函数的地址存到一个函数指针变量里呢？
来看看下面的一段代码
#include <stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
printf("%p", &Add);
return 0;
}【程序结果】
通过以上代码我们发现，函数名也是有地址的，所以我们能不能创建一个变量并把这个地址存起来呢？
#include <stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
int (*p)(int, int) = &Add;
return 0;
}
接下来还能类比，&arr不加&，arr则是数组首元素的地址，如果不&数组名，那么单独的数组名是否是函数首元素的地址呢？
让我们用代码说话
总结：&数组名和数组名都是函数的地址。
2、函数指针的使用
既然p指向Add函数，所以能不能用p来调用Add函数呢？
这时就得用到解引用操作符
不能口说无凭，咱代码说话
#include <stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
int (*p)(int, int) = &Add;
//对指针p解引用找到Add函数
int res = (*p)(100, 200);
printf("%d\n", res);
return 0;
}【程序运行结果】
这样一串下来，我们就发现一段关系
*p == Add == &Add == p
所以上述的代码中，解引用操作符就可以去掉了
六、函数指针数组
1、函数指针数组的定义
函数指针数组本质上是一个数组，是用来存放函数地址的数组。
类比一下：
指针数组
//存放的是字符指针
char* arr[10];
//存放整型指针
int* arr[10];
//那么函数指针就是存放 函数指针的数组
例如：
int Add(int x,int y)
{
return x + y;
}
int main()
{
int (*p)(int,int) = &Add //函数指针
//函数指针数组就是基于函数指针改造的
//函数指针数组本质上是个数组
int (*p[3])(int,int) = {&Add};
//[]的优先级高于*,所以p先和[]结合，所以p是个数组
//类型是 int (*)(int,int) -->函数指针类型
}2、函数指针数组的用途
在讲函数指针数组用途之前，首先用代码为大家实现一个计算器，能实现加、减、乘、除的功能。
这和以往猜数字的模式差不多 点击跳转猜数字小游戏
【代码实现】
#include <stdio.h>
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
int Mul(int x,int y)
{
return x * y;
}
int Div(int x, int y)
{
return x / y;
}
void menu()
{
printf("*******************************\n");
printf("**** 1.Add 2.Sub ****\n");
printf("**** 3.Mul 4.Div ****\n");
printf("***** 0.Exit ****\n");
printf("*******************************\n");
}
int main()
{
int input = 0;
int x = 0;
int y = 0;
int res = 0;
do
{
menu(); //打印菜单
printf("请选择：");
scanf("%d", &input);
switch (input)
{
case 1:
printf("请输入两个整数：");
scanf("%d %d", &x, &y);
res = Add(x, y);
printf("相加的结果为：%d\n", res);
break;
case 2:
printf("请输入两个整数：");
scanf("%d %d", &x, &y);
res = Sub(x, y);
printf("相减的结果为：%d\n", res);
break;
case 3:
printf("请输入两个整数：");
scanf("%d %d", &x, &y);
res = Mul(x, y);
printf("相乘的结果为：%d\n", res);
break;
case 4:
printf("请输入两个整数：");
scanf("%d %d", &x, &y);
res = Div(x, y);
printf("相除的结果为：%d\n", res);
break;
case 0:
printf("退出计算器");
break;
default:
printf("选择错误\n");
break;
}
} while (input);
}【程序运行结果】
若此时计算器中还要加入按位与&、按位或|等操作符运算，虽然只要在代码内部多加几行函数，但这也会导致代码越来越来长。所以，可以使用函数指针数组来分别存放Add、Sub的地址
【代码实现】
#include <stdio.h>
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
int Mul(int x,int y)
{
return x * y;
}
int Div(int x, int y)
{
return x / y;
}
void menu()
{
printf("*******************************\n");
printf("**** 1.Add 2.Sub ****\n");
printf("**** 3.Mul 4.Div ****\n");
printf("***** 0.Exit ****\n");
printf("*******************************\n");
}
//函数指针数组
int (*p[5])(int, int) = { 0,Add,Sub,Mul,Div };
//这里的0，是为了和菜单对应，当然也可以写NULL
int main()
{
int input = 0;
int x = 0;
int y = 0;
int res = 0;
do
{
menu(); //打印菜单
printf("请选择：");
scanf("%d", &input);
if (input == 0)
{
printf("退出计算器\n");
break;
}
else if (input >= 1 && input <= 4)
{
printf("请输入两个整数：");
scanf("%d %d", &x, &y);
//当input为0则退出,
//当input为1则调用Add函数
//以此类推...
int res = p[input](x, y);
printf("结果为：%d\n", res);
}
else
{
printf("选择错误，请重新选择\n");
}
} while (input);
}【程序运行结果】
七、指向函数指针数组的指针
指向函数指针数组的指针本质上是个指针
指针指向一个数组
数组每个元素的类型都是函数指针
1、定义
int Add(int x, int y)
{
return x + y;
}
int main()
{
//整型数组
//arr是数组，&arr
int arr[10] = { 0 };
int(*p)[10] = &arr; //数组指针
//函数指针数组
//同样的，p也是个数组，也&p
int (*p[3])(int, int);
int (*(*pp)[3])(int, int) = &p; //这就是指向函数指针数组的指针
}用概念再来分析一下
int (*(*pp)[3])(int, int) = &p
①pp先和*结合，说明pp是一个指针
②指向一个数组有3个元素
③每个元素的类型都是int (*)(int, int) --> 函数指针类型
Q：这么复杂类型怎么看？
int (*
(*pp)[3])(int, int)，把(*pp)[3]去掉，剩下就是类型
八、回调函数
回调函数就是一个通过函数指针调用的函数。
就像上面的代码，方框部分是有大部分代码是重复的，我们可以利用回调函数的方式来把它变得更加简洁
【代码实现】
#include <stdio.h>
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
int Mul(int x, int y)
{
return x * y;
}
int Div(int x, int y)
{
return x / y;
}
void calc(int (*p)(int ,int)) //函数传参，函数指针接收
{
int x = 0;
int y = 0;
printf("请输入两个整数：");
scanf("%d %d", &x, &y);
int res = p(x, y);
printf("计算结果为：%d\n",res);
}
void menu()
{
printf("*******************************\n");
printf("**** 1.Add 2.Sub ****\n");
printf("**** 3.Mul 4.Div ****\n");
printf("***** 0.Exit ****\n");
printf("*******************************\n");
}
int main()
{
int input = 0;
do
{
menu(); //打印菜单
printf("请选择：");
scanf("%d", &input);
switch (input)
{
case 1:
calc(Add);
break;
case 2:
calc(Sub);
break;
case 3:
calc(Mul);
break;
case 4:
calc(Div);
case 0:
printf("退出计算器");
break;
default:
printf("选择错误\n");
break;
}
} while (input);
}
九、总结
本章重点讲解了数组指针、数组传参、指针传参、函数指针、回调函数和函数指针数组等内容。欲知后事如何，关注博主，下期更精彩！！
