目录
九、函数指针数组
1、字符指针变量
在指针的类型中我们知道有一种指针类型为字符指针 char* ;一般使用:
int main()
{
char ch = 'w';
char *pc = &ch;
*pc = 'w';
return 0;
}还有⼀种使用方式如下：代码 const char* pstr = "hello bit."; 特别容易让同学以为是把字符串 hello bit 放到字符指针 pstr 里了，但是本质是把字符串 hello bit. 首字符的地址放到了pstr中。
int main()
{
const char* pstr = "hello bit.";//这⾥是把⼀个字符地址存放在p中
printf("%s\n", pstr);
return 0;
}
所以可以把字符串想象成一个数组：
注：①当常量字符串常量出现在表达式中的时候，他的值是第一个字符的地址。 ②虽然可以把字符串看成一个字符数组，但是这个数组是不能修改的，因为它是常量不是变量。
《剑指offer》中的一道和字符串相关的笔试题：
#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、数组指针变量
注意：指针数组是一种数组，数组中存放的是地址（指针）。
数组指针变量是指针变量，而不是数组。
#include <stdio.h>
int main()
{
int n = 100;
int* pn = &n;
char ch = 'w';
char* pc = &ch;
float f = 3.14;
float* pf = &f;
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int(*parr)[10] = &arr;//取出的是数组的地址
//parr就是数组指针
return 0;
}
元素地址与数组地址的区别：
数组指针如何应用：（打印数组元素为例）（因为数组指针的特点，一维数组基本不会使用）
#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//指针访问数组
int(*p)[10] = &arr; //p3是数组地址
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
for (i = 0; i < sz; i++)
{
printf("%d ", (*p)[i]);
// p == &arr
// *p == *&arr == arr
}
return 0;
}3、二维数组传参的本质
#include <stdio.h>
void test(int a[3][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 ", 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;
}
所以，根据数组名是数组首元素的地址这个规则，二维数组的数组名表示的就是第一行的地址，是一维数组的地址。根据上面的例子，第一行的一维数组的类型就是 int [5] ，所以第一行的地址的类型就是数组指针类型 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)); //p = &arr,p+i=&arr+i,*(p+i)=arr[i]
}
printf("\n");
}
}
方式二：
void test(int(*arr)[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 ", 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;
}
通俗理解：由于二维数组由若干个一维数组构成，那么二维数组的数组名即为第一行的一维数组地址， 地址+整数=地址，所以 + i 表示指到第 i 行的地址。当拿到第 i 行数组名（即地址），解引用后（ *(p+i) ）则得到了该行首元素的地址，此时与一维数组原理相似。
4、函数指针变量
函数指针变量也是指针变量，其存储的地址指向函数而不是普通变量。在C语言和C++中，函数指针变量可以用来存储函数的地址，从而可以通过该指针调用相应的函数。 下面做个测试：
可以发现函数的确有地址。函数名就是函数的地址，当然也可以通过 &函数名 的方式获得函数的地址。
数组名：数组首元素的地址
&数组名：整个数组的地址
函数名==&函数名：函数的地址
函数指针变量的声明通常形式为：
return_type (*function_pointer_name)(parameter_list);
其中 return_type 表示函数返回类型，function_pointer_name 是函数指针变量的名称，parameter_list是函数的参数列表。 如果我们要将函数的地址存放起来，就得创建函数指针变量，函数指针变量的写法其实和数组指针非常类似。
void test()
{
printf("hehe\n");
}
void (*pf1)() = &test;//&test等价于test
void (*pf2)() = test;
int Add(int x, int y)
{
return x + y;
}
int(*pf3)(int, int) = Add;
int(*pf3)(int x, int y) = &Add;//x和y写上或者省略都是可以
函数指针变量的使用：
声明了一个指向函数的指针 pf3，它接受两个整型参数并返回一个整型结果。在这里，pf3 被赋值为 Add 函数的地址，也就是说，它指向了 Add 函数的代码块。
pf3是一个指向函数的指针，它里面包含了函数的地址。*pf3表示解引用这个指针，也就是得到指针所指向的函数。(*pf3)(2, 3)表示调用这个函数，传递参数 2 和 3 给它。
而当写 pf3(2, 3) 时，因为函数名实际上就是函数的地址，所以直接使用 pf3（函数指针）并传递参数给它，就相当于直接调用了 Add 函数，所以 (*pf3)(2,3) 和 pf3(2,3) 结果相同。
4.1 分析《C陷阱和缺陷》中的两端代码
( *( void (*)() )0 )();void(*)( ) --- 函数指针类型， （int）3.14 --- 强制类型转换
上面的代码是一次函数调用：
1.把0这个整数值强制类型转换成一个函数地址，这个函数没有参数，返回类型是void
2.去调用0地址处的函数
void (*signal(int , void(*)(int) ) )(int);signal没有和指针括在一起，由于括号的优先级更高，所以signal是函数名。
4.2 typedef关键字
typedef是用来类型重命名的，可以将复杂的类型简单化。比如，你觉得 unsigned int 写起来不方便，如果能写成 uint 就方便多了，那么我们可以使用：
typedef unsigned int uint;
//将unsigned int 重命名为uint如果是指针类型，能否重命名呢？其实也是可以的，比如，将 int* 重命名为 ptr_t ,这样写：
typedef int* ptr_t;但是对于数组指针和函数指针稍微有点区别：比如我们有数组指针类型 int(*)[5] ,需要重命名为 parr_t ，那可以这样写：
typedef int(*parr_t)[5]; //新的类型名必须在*的右边函数指针类型的重命名也是一样的，比如，将 void(*)(int，int) 类型重命名为 pf_t ,就可以这样写：
typedef void(*pfun_t)(int，int);//新的类型名必须在*的右边#include<stdio.h>
typedef unsigned int uint;
typedef int(*pArr_t)[10]; //对于数组、函数指针时不能将名字放在后面，而是*的右边
void (*pf_t)(int, int);
int main()
{
unsigned int num;
uint num2;
int(*pb)[10];
pArr_t pa;
void(*pf1)(int，int);
pf_t pf;
return 0;
}利用 tepedef 对 void (*signal(int , void(*)(int) ) )(int); 进行简化：
void (*signal(int, void(*)(int)))(int);
typedef void(*pf_t)(int);
pf_t signal(int, pf_t);5、函数指针数组
指针数组 --- 是数组，每个元素是指针，char* arr[5], double* arr[5]
数组指针 --- 是指针，指向数组的指针，int(*pa)[10]=&arr, char(*pa)[5]=&arr
数组是一个存放相同类型数据的存储空间，那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，是数组，里面的元素是函数指针。
再次理解函数指针：
#include<stdio.h>
int test(char* c,int n)
{
//...
return 0;
}
int main()
{
int (*pf)(char*, int) = &test;
(*pf)("abcdef", 10);
pf("abcdef", 10);
test("abcdef", 10)
return 0;
}函数指针数组实例：
#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;
}
int main()
{
int (*pf)(int, int) = Add; //pf是函数指针
int (*pf1[4])(int,int) = { Add,Sub,Mul,Div };//存放函数指针的数组
// 0 1 2 3
int i = 0;
for (i = 0; i < 4; i++)
{
int result=pf1[i](6, 2);
/*int result = (*pf1[i])(6, 2);*/
printf("%d\n", result);
}
return 0;
}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_s("%d", &input);
if ((input <= 4 && input >= 1))
{
printf("输⼊操作数：");
scanf_s("%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;
}跳转其他页面：
753
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
