1. 字符型指针变量
在指针类型中有⼀种类型为字符指针，用符号char*来表示。
它的一般的使用方法如下：
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
char ch = 'w';
char *pc = &ch;
*pc = 'w';
return 0;
}
另外，它还有一种使用方式：
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
char* p = "abcdefghi";//这里是将abcdefgi\0字符串存放到p中了吗？
//"abcdefghi"是一个常量字符串，是不能被修改的
//[abcdefghi\0]字符串其实和数组很相似
//b = 2 + 3
//表达式有两个属性：值属性，类型属性
//2 + 3 值是5
//2 + 3 int
printf("%c\n", *p);
return 0;
}
代码运行结果：
这里特别容易让小伙伴们以为是把字符串 “abcdefghi” 放到字符指针 p 里了，但本质上是把字符串 “abcdefghi” 的首字符 “a” 的地址放到了p中。
《剑指offer》中收录了⼀道和字符串相关的笔试题，我们⼀起来学习⼀下：
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
char str1[] = "hello bit.";
char str2[] = "hello bit.";
const char *str3 = "hello bit.";
const char *str4 = "hello bit.";
if (str1 == str2)
printf("str1 and str2 are same\n");
else
printf("str1 and str2 are not same\n");
if (str3 == str4)
printf("str3 and str4 are same\n");
else
printf("str3 and str4 are not same\n");
return 0;
}
运行结果：
为什么会是上面两种结果呢？诶，别着急，接下来我们慢慢分析原因。
在这里，两者都是进行地址的比较，str3和str4指向的是同⼀个常量字符串。C/C++会把常量字符串存储到单独的⼀个内存区域，当几个指针指向同⼀个字符串的时候，他们实际会指向同⼀块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4相同。
2. 数组指针变量
2.1 什么是数组指针变量
之前我们学习了指针数组，指针数组是⼀种数组，数组中存放的是地址（指针）。那数组指针变量是指针，还是数组呢？
答案是指针。
我们已经熟悉：
1、整形指针变量： int* pint；存放的是整形变量的地址，是指向整形数据的指针。int n = 100; int* p = &n;
2、浮点型指针变量： float* pf；存放浮点型变量的地址，是指向浮点型数据的指针。float ch = ‘w’; float* pc = &w;
那么数组指针变量应该是：存放的是数组的地址，是指向数组的指针变量。
很多小伙伴可能会问：数组指针该怎么表示呢？
一些小伙伴心想：数组的一般形式为int arr[10]，那么数组指针就应该表示为int [10]* p，这就是“经典的错误，标准的零分”！
事实上，数组指针的正确是写法应该是：int (*p)[10]。
为什么应该是上面这种形式呢？别着急，听我慢慢道来。
这里p先和*相结合，说明p是⼀个指针变量，然后再指向⼀个大小为10个整型的数组。我们知道，[ ]的优先级是高于*号的，所以必须加上 () 来保证p先和*结合！
2.2 通过数组指针变量访问数组
我们之前尝试过使用数组名去访问数组中的元素，同样我们也能够通过数组指针来访问数组的元素，但首先我们得获取数组的地址，那么该怎么获取呢？
其实很简单，不知道小伙伴们是否还记得前面我们讲过，数组名是首元素的地址，但是存在两个前提条件，其中一条便是 &数组名，这里的数组名表示整个数组，&数组名取出的就是整个数组的地址。
int main()
{
int arr[10] = { 0 };
// arr;//数组首元素的地址 — int*;
// &arr;//得到的就是数组的地址 — int(*)[10];
}
之前的写法：
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int* p = arr;
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", p[i]);
}
}
运行结果：
数组指针的写法：
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int(*p)[10] = &arr;
int i = 0;
for (i = 0; i < 10; i++)
{
//(*p)—p存放的是整个数组的地址，*p好像拿到的就是整个数组，其实不然，*p拿到的其实是数组名
//(*&arr)
//arr
printf("%d ", (*p)[i]);
}
return 0;
}
运行结果：
虽然上述两种代码都能实现数组访问功能，但依然推荐以前的写法，原因在于第二种写法写出来的代码看着很别扭！
既然不建议用数组指针来访问数组，那数组指针有什么用呢？不理解没关系，我们接着往下讲。
3. 二维数组传参本质
只有解决了二维数组传参本质，我们就把数组指针掌握了。
过去我们有⼀个⼆维数组的需要传参给⼀个函数的时候，我们这样写：
void test(int (*arr)[5], int r, int c)
{
int i = 0;
for (i = 0; i < r; i++)
{
int j = 0;
for (j = 0; j < c; j++)
{
//printf("%d ", arr[i][j]);
//printf("%d ", *(*(arr + i) + j));
printf("%d ", (*(arr + i))[j]);
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { { 1, 2, 3, 4, 5 }, { 2, 3, 4, 5, 6 }, { 3, 4, 5, 6, 7 } };
test(arr, 3, 5);
return 0;
}
运行结果：
这里实参是⼆维数组，形参也写成⼆维数组的形式，那还有什么其他的写法吗？
首先我们再次理解⼀下⼆维数组，二维数组的每一行是一个一维数组，这个一维数组可以看作是二维数组的一个元素，所以二维数组也可以认为是一维数组的数组。
根据数组名是数组首元素的地址这个规则，⼆维数组的数组名表示的就是第一行的地址，即是一维数组的地址。根据上面的实例，第一行的⼀维数组的类型就是 int [5] ，所以第一行的地址类型就是数组指针类型 int(*)[5] 。
这就意味着⼆维数组传参本质上也是传递了地址，传递的是第一行这个一维数组的地址，那么形参也是可以写成指针形式的。
void test(int (*arr)[5], int r, int c)
{
int i = 0;
for (i = 0; i < r; i++)
{
int j = 0;
for (j = 0; j < c; j++)
{
//printf("%d ", arr[i][j]);
//printf("%d ", *(*(arr + i) + j));
printf("%d ", (*(arr + i))[j]);
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { { 1, 2, 3, 4, 5 }, { 2, 3, 4, 5, 6 }, { 3, 4, 5, 6, 7 } };
//二维数组传参，传递的是首元素的地址，也就是第一行的地址
//形参的部分就可以写成指向第一行的地址
test(arr, 3, 5);
return 0;
}
运行结果：
总结：⼆维数组传参，形参的部分可以写成数组，也可以写成指针形式。
4. 函数指针变量
4.1 函数指针变量的创建与使用
在讲解函数指针变量之前，我们先思考一下什么是函数指针变量，我们可以同数组指针变量进行类比：
数组指针—是指针—是存放指向数组的指针，是存放数组地址的指针；
函数指针—是指针—是存放指向函数的指针，是存放函数地址的指针；
数组是有地址的，那么函数是否也有地址呢？
我们来做个测试：
#include <stdio.h>
void test()
{
printf("hehe\n");
}
int main()
{
printf("test: %p\n", test);
printf("&test: %p\n", &test);
return 0;
}
运行结果：
我们发现：确实打印出来了地址，所以函数是有地址的，并且同数组名是数组首元素地址一样，函数名也是函数的地址，我们可以通过 &函数名 的方式来获得函数的地址。
如果我们要将函数的地址存放起来，就得创建函数指针变量咯，而函数指针变量的写法和数组指针也有许多相似之处：
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int add(int x, int y)
{
return x + y;
}
int main()
{
int (*pf)(int x, int y) = &add;
//int——表示pf指向函数的返回类型
//pf——函数指针变量名
//int x, int y——pf指向函数的参数类型和个数的交代
int ret = (*pf)(3, 5);
printf("%d\n", ret);
return 0;
}
运行结果：
函数指针的主要用途在于通过函数指针调用指针指向的函数，具体实例如上所示。
4.2 两段有趣的代码
代码1：
(*(void (*)())0)();
代码解释：
在这里，我们把0强制类型转换成函数指针类型，这个函数指针参数是无参，返回值类型是void，然后通过解引用去调用函数。
注：这里的 * 可以省略
void (*)() — 是函数指针，参数是无参，返回类型是void。
(void (*)()) — 函数指针外面加上括号，表示强制类型转换。
代码2：
void (*signal(int , void(*)(int)))(int);
代码解释：
signal是一个函数的函数名，上面的代码是一次函数，函数的参数是类型int和函数指针，该函数的函数指针参数是int，返回类型是void；signal函数的返回类型也是一个函数指针，该函数的函数指针参数类型和返回值也是int和void。
我们可以进行拆开：
signal(int , void(*)(int)) — signal函数。
void (*)(int) — 函数指针（signal函数返回类型）。
可能有小伙伴觉得这种写法太复杂了，想简化成下面这种形式：
void (*)(int) signal(int , void(*)(int))
很遗憾，上面这种写法是错误的。
事实上，在C语言中有一个关键字叫typedef，我们可以用它来将复杂的类型简单化。
4.2.1 typedef关键字
我们可以用typedef关键字来简化signal函数：
//typedef unsiged int uint;
//将unsigned int 重命名为uint
typedef void(*pf_t)(int)//typedef void(*)(int) pf_t;但是不对
int main()
{
//uint a = 10; ---> unsigned int b = 10;
void(* singal(int, void(*)(int)))(int);
pf_t signal(int, pf_t);
return 0;
}
运行结果：
我们发现，代码完全正确，没有任何错误警告。
如果不够直观，没关系，我们也可以用typedef来简化数组并打印出结果：
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//typedef 数组
typedef int(*parr)[6];
int main()
{
int arr[6] = { 0 };
int(*p)[6] = &arr;
parr pa = &arr;
printf("%p\n", p);
printf("%p\n", pa);
return 0;
}
运行结果：
我们可以发现，p 和pa 的结果一样，都表示数组的地址。
5. 函数指针数组
数组是⼀个存放相同类型数据的存储空间，我们已经学习了指针，比如：
int (*parr)[10]
如果我们把若干个相同类型函数的地址存到⼀个数组中，那么这个数组就叫函数指针数组。
那么函数指针的数组该如何定义呢？
其实很简单，我们可以仿造指针数组来创建一个函数指针数组：
int add(int x, int y)
{
return x + y;
}
int sub(int x, int y)
{
return x - y;
}
int main()
{
int* arr[10];//整型指针数组
int(*p1)(int, int) = add;
int(*p2)(int, int) = sub;
//p1的类型和p2的类型一模一样，就想着把p1、p2放到一个数组里边去
//
//函数指针数组
int(*parr[4])(int, int) = { add, sub };//int (* )(int, int) = { add, sub }—元素类型
return 0;
}
6. 转移表（函数指针数组的用途）
学习了函数指针数组的创建，可能小伙伴们会想，函数指针数组到底有什么用呢？
别着急，函数指针的用途可大了。
比如说，我们要写一段代码来实现计算器。
我们可以采用一般写法：
#define _CRT_SECURE_NO_WARNINGS
#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****\n");
printf("*****2.sub****\n");
printf("*****3.mul****\n");
printf("*****4.div****\n");
printf("*****0.exit****\n");
printf("**************\n");
}
int main()
{
int x = 0;
int y = 0;
int ret = 0;
int input = 0;
do{
menu();
printf("请选择：");
scanf("%d", &input);
switch (input)
{
case 1:
printf("请输入两个数：");
scanf("%d %d", &x, &y);
ret = add(x, y);
printf("%d\n", ret);
break;
case 2:
printf("请输入两个数：");
scanf("%d %d", &x, &y);
ret = sub(x, y);
printf("%d\n", ret);
break;
case 3:
printf("请输入两个数：");
scanf("%d %d", &x, &y);
ret = mul(x, y);
printf("%d\n", ret);
break;
case 4:
printf("请输入两个数：");
scanf("%d %d", &x, &y);
ret = div(x, y);
printf("%d\n", ret);
break;
case 0:
printf("退出计算器\n");
break;
default:
printf("选择错误，重新选择\n");
break;
}
} while (input);
}
运行结果：
我们发现，确实能够实现计算器的加减乘除功能，但是我们也观察到，随着计算器功能增加，代码也会越来越长。显然，这样的代码显得太冗余了，我也需要对其进行改造。而要进行改造，我们就不得不利用函数指针！
改造后：
#define _CRT_SECURE_NO_WARNINGS
#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******\n");
printf("*****2.sub******\n");
printf("*****3.mul******\n");
printf("*****4.div******\n");
printf("*****0.exit*****\n");
printf("****************\n");
}
int main()
{
//函数指针的数组
int(*parr[])(int, int) = { 0, add, sub, mul, div };
int x = 0;
int y = 0;
int ret = 0;
int input = 0;
do{
menu();
printf("请选择：");
scanf("%d", &input);
if (input >= 1 && input <= 4)
{
printf("请输入两个数：");
scanf("%d %d", &x, &y);
ret = parr[input](x, y);
printf("%d\n", ret);
}
else if (input == 0)
{
printf("退出计算器\n");
}
else
{
printf("选择错误，重新选择\n");
}
} while (input);
}
运行结果：
我们发现，结果依然是正确的，但是这样的代码就没有了上面那样的冗余，我们通过一个下标，在函数指针数组里面找到了一个函数的地址，然后通过这个地址去调用这个函数，直接传参得出结果，这个效率就快得多。
这里我们用函数指针数组做了一个跳转或者转移，我们把这样的函数指针数组称为转移表。
但是转移表有自己的局限性，它里面只能存放相同类型的函数，即只能计算整数，不能计算浮点数！
当然，我们还有更高效的实现方法，具体如何去实现，这是我们下期的内容。如果感觉本期内容还不错的话，还请小伙伴们多多点赞并转发，你们的支持是我前进的最大动力。
518
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
