- 前言：
- 正文
- 1. 字符指针变量
- 2. 数组指针变量
- 2.1 数组指针变量是什么?
- 2.2 数组指针变量怎么初始化
- 3. 二维数组传参的本质
- 4. 函数指针变量
- 4.1 函数指针变量的创建
- 4.2 函数指针变量的使用
- 4.3 两段有趣的代码
- 4.3.1 typedef关键字
- 5. 函数指针数组
- 6. 转移表
- 总结
前言：
这是指针第四篇，主要介绍：字符指针变量、数组指针变量、二维数组传参的本质、函数指针变量、函数指针数组以及函数指针数组的应用——转移表
正文
1. 字符指针变量
在指针的类型中有一种指针类型为字符指针char*。
一般使用方式如下：
int main()
{
char ch = 'w';
char *pc = &ch;
*pc = 'w';
return 0;
}
还有一种使用方式如下：
int main()
{
const char* ps = "hello C.";
printf("%s\n", ps);
return 0;
}
代码const char* ps = "hello C";容易让人以为是把字符串hello C放到字符指针ps里了，但是本质是把字符串hello C.首字符的地址放到了ps中。实际是把一个常量字符串的首字符h的地址存放到指针变量ps中。
《剑指offer》中又一道与之相关的题目，代码如下：
#include <stdio.h>
int main()
{
char str1[] = "hello C.";
char str2[] = "hello C.";
const char *str3 = "hello C.";
const char *str4 = "hello C.";
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;
}
为什么会有这样的结果呢？const修饰常量字符串，str3和strr4是指向同一个字符串的，在C语言中会把常量字符串单独存储到一个内存区域，虽然str3和str4变量名不同，但实际上指向同一片内存空间。然而，用同样的字符串初始化不同数组时会形成不同空间，即不同的内存块。所以str1和str2不同，str3和str4相同。
2. 数组指针变量
2.1 数组指针变量是什么?
先区分一下，之前学过指针数组,它是一种数组，用来存放指针（也就是地址）
而数组指针变量，和·指针数组·不同，它是指针变量
举个栗子：
int* pint 表示整型指针变量用来存放整型变量的地址
float* pf表示浮点型指针变量 ， 用来存放浮点型数据的地址
数组指针变量存放的是数组的地址，能够指向数组的指针变量。
这里用两个代码经常混淆
int *p1[10];
int(*p2)[10];
哪一个是数组指针变量呢？答案是p2即int(*p2)[10];p1是指针数组，p2先和结合，说明p2是一个指针变量，然后指针指向的是一个大小为 10 个整型的数组，所以p2是一个指针，指向一个数组，叫数组指针。
注意：[]的优先级是高于的，所以必须加上（）保证*和p是一起的
2.2 数组指针变量怎么初始化
数组指针变量是用来存放数组地址的，通过&数组名可以获得数组的地址。例如：
int arr[10] = {0};
&arr;
如果要存放数组的地址，就得存放在数组指针变量中，如下：
int(*p)[10] = &arr;
调试可以看到&arr和p的类型是完全一致的。
数组指针类型解析：
3. 二维数组传参的本质
有了数组指针的基础理解，就能够讲一下二维数组传参的本质。
过去二维数组传参给一个函数时，写法如下：
#include <stdio.h>
void test(int a[3][5], int a, int b)
{
int i = 0;
int j = 0;
for(i=0; i<a; i++)
{
for(j=0; j<b; j++)
{
printf("%d ", a[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;
}
| 0 0 0 | 1 1 1 | 2 2 2 | 3 3 3 | 4 4 4 | |
|---|---|---|---|---|---|
| 0 0 0 | 1 1 1 | 2 2 2 | 3 3 3 | 4 4 4 | 5 5 5 |
| 1 1 1 | 2 2 2 | 3 3 3 | 4 4 4 | 5 5 5 | 6 6 6 |
| 2 2 2 | 3 3 3 | 4 4 4 | 5 5 5 | 6 6 6 | 7 7 7 |
arr数组 内容如上
实参是二维数组，形参也是二维数组，但是前面说过二维数组其实是一维数组的数组，二维数组的首元素是第一行，是一维数组，所以我们可以这样理解：二维数组数组名是第一行的地址，是一维数组的地址（指针），第一行的一维数组类型就是int [5]，so,第一行的地址类型就是数组指针类型int(*) [5].这表示二维数组传参本质上也是传递了地址，传递的是第一行这个一维数组的地址，那么形参也是可以写成指针形式的，如下：
#include <stdio.h>
void test(int (*p)[5], int r, int c)
{
int i = 0;
int j = 0;
for(i=0; i<r; i++)
{
for(j=0; j<c; j++)
{
printf("%d ", *(*(p+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;
}
输出结果中test和&test的地址相同，函数名就是函数的地址，也可以通过&函数名的方式获得函数的地址。
如果要将函数的地址存放起来，就得创建函数指针变量，函数指针变量的写法和数组指针非常类似。例如：
void test()
{
printf("hehe\n");
}
void (*pf1)() = &test;
void (*pf2)()= test;
int Add(int x, int y)
{
return x+y;
}
int(*pf3)(int x, int y) = &Add;
int(*pf3)(int, int) = Add;
函数指针类型解析：
int (*pf3) ( int x, int y)
//( int x, int y)——指向函数的参数类型和个数的交代
//(*pf3) ——函数指针变量名
//int ——pf3指向函数的返回类型
int (*) (int x, int y) //pf3函数指针变量的类型
4.2 函数指针变量的使用
现在写一个加法的函数，你可能会这样写：
int add(int x,int y)
{
return x + y;
}
int main()
{
int r = add(2,5);
printf("%d",r);
return 0;
}
但我们学过上述内容后，通过函数指针调用指针指向的函数，示例代码如下：
#include <stdio.h>
int Add(int x, int y)
{
return x+y;
}
int main()
{
int(*pf3)(int, int) = Add;
printf("%d\n", (*pf3)(2, 3));
printf("%d\n", pf3(3, 5));
return 0;
}
4.3 两段有趣的代码
(*(void (*)())0)();
void (*signal(int , void(*)(int)))(int);
两段代码均出自《C陷阱和缺陷》这本书。
可以自己写出来理解一下，正常情况我们不会这样写，实在理解不了也没关系，（也可以问问deepseek）.
4.3.1 typedef关键字
typedef是用来类型重命名的，可以将复杂的类型简单化。比如将unsigned int重命名为uint：
typedef unsigned int uint;
对于指针类型也能重命名，将int*重命名为ptr_t：
typedef int* ptr_t;
对于数组指针和函数指针重命名稍有区别。将数组指针类型int(*)[5]重命名为parr_t：
typedef int(*parr_t)[5];
将函数指针类型void(*)(int)重命名为pf_t：
typedef void(*pfun_t)(int);
简化代码2可以这样写：
typedef void(*pfun_t)(int);
pfun_t signal(int, pfun_t);
5. 函数指针数组
数组是一个存放相同类型数据的存储空间，已经学习了指针数组，例如int * arr[10];，数组的每个元素是int*。
把函数的地址存到一个数组中，这个数组就叫函数指针数组。函数指针数组定义为int (*parr1[3])();，parr1先和[]结合，说明parr1是数组，数组的内容是int (*)()类型的函数指针。
6. 转移表
函数指针数组的用途之一是转移表。
例如计算器的一般实现代码如下：
#include <stdio.h>
int add(int a, int b)
{
return a + b;
}
int sub(int a, int b)
{
return a - b;
}
int mul(int a, int b)
{
return a * b;
}
int div(int a, int b)
{
return a / b;
}
int main()
{
int x, y;
int input = 1;
int ret = 0;
do
{
printf("*************************\n");
printf(" 1:add 2:sub \n");
printf(" 3:mul 4:div \n");
printf(" 0:exit \n" );
printf("*************************\n");
printf("请选择:");
scanf("%d", &input);
switch (input)
{
case 1:
printf("输入操作数:");
scanf("%d %d", &x, &y);
ret = add(x, y);
printf("ret = %d\n", ret);
break;
case 2:
printf("输入操作数:");
scanf("%d %d", &x, &y);
ret = sub(x, y);
printf("ret = %d\n", ret);
break;
case 3:
printf("输入操作数:");
scanf("%d %d", &x, &y);
ret = mul(x, y);
printf("ret = %d\n", ret);
break;
case 4:
printf("输入操作数:");
scanf("%d %d", &x, &y);
ret = div(x, y);
printf("ret = %d\n", ret);
break;
case 0:
printf("退出程序\n");
break;
default:
printf("选择错误\n");
break;
}
} while (input);
return 0;
}
使用函数指针数组的实现：
#include <stdio.h>
int add(int a, int b)
{
return a + b;
}
int sub(int a, int b)
{
return a - b;
}
int mul(int a, int b)
{
return a*b;
}
int div(int a, int b)
{
return a / b;
}
int main()
{
int x, y;
int input = 1;
int ret=0;
int(*p[5])(int x, int y) = { 0, add, sub, mul, div };
do
{
printf("*************************\n");
printf(" 1:add 2:sub \n");
printf(" 3:mul 4:div \n");
printf(" 0:exit \n" );
printf("*************************\n");
printf("请选择:");
scanf("%d", &input);
if ((input <= 4 && input >= 1))
{
printf("输入操作数:");
scanf("%d %d", &x, &y);
ret = (*p[input])(x, y);
printf("ret = %d\n", ret);
}
else if(input == 0)
{
printf("退出计算器\n");
}
else
{
printf("输入有误，重新选择\n");
}
}while (input);
return 0;
}
总结
本文就到这里了，如有误，欢迎指正，指针很难，但坚持下去，终有收获，朋友，把这件事坚持下去吧。
敬，不完美的明天。
