C++中对比：指针、函数指针、typedef 定义函数指针、指针函数

本文链接：https://blog.youkuaiyun.com/m0_58242248/article/details/136512289

一、首先说说为什么要使用指针？

【参考文章】https://blog.youkuaiyun.com/galaxyrt/article/details/117253022?utm_medium=distribute.pc_relevant.none-task-blog-2_defaultbaidujs_baidulandingword~default-0-117253022-blog-108021300.235^v43pc_blog_bottom_relevance_base2&spm=1001.2101.3001.4242.1&utm_relevant_index=3

函数的缺陷：一个函数只能返回一个值，就算我们在函数里面写多了return语句，但是只要执行任何一条return语句，整个函数调用就结束了。
数组：可以帮助我们返回多个值，但是数组是相同数据类型的结合，对于不同数据类型则不能使用数组。
指针：使用指针我们想反回几个值就能返回几个值，想返回什么类型就可以返回什么类型的值。参考：https://blog.youkuaiyun.com/A37644548/article/details/134452749

二、指针，函数指针，指针函数的介绍

【参考文章1】https://blog.youkuaiyun.com/weixin_42803147/article/details/108021300
【参考文章2】https://blog.youkuaiyun.com/qq_27825451/article/details/103081289
【参考文章3】https://blog.youkuaiyun.com/baidu_37973494/article/details/83150266

2.1 什么是指针、函数指针，指针函数？

指针：指向变量的地址
函数指针：即定义一个指向函数的指针变量。本质是指针变量。指向的是函数的地址。
指针函数：指的是函数的返回值是一个指针。联想一下void 。指针函数实质是一个函数。函数都有返回类型（如果不返回值，则为void），只不过指针函数返回类型是某一类型的指针。将void变为int* 。

2.1 对比：指针、函数指针、指针函数的声明？

声明一个int型指针：

int *p ;

声明一个函数型（假如是一个有两个int类型的参数以及一个 int类型的返回值）的指针。格式：类型名 (*函数名)(函数参数列表);

int (*pFunc)(int, int);    //注意：这里的括号不能去掉，因为括号()的运算优先级比解引用运算符*高

声明一个指针函数，比如返回的是一个指向整数int的指针。格式：类型名 *函数名(函数参数列表);

int *p(int a,int b); //注意这里的*与P之间是没有括号的，所以含义是函数p(int,int)会返回一个（int *）指针

将指针名称提取出去：

整形指针	函数指针	指针函数
int*	int (*)(int, int)	int* (int, int)

对比对比

2.2 对比：指针、函数指针的使用？

int型指针的使用：

#include<iostream>
int main()
{
    int num = 20;
    // int指针声明， 这里没有直接指向NULL
    int *p;
    // 指针指向num的地址， 整形变量取得地址要用 &
    p = &num;
    // 打印结果
    std::cout << *p <<std::endl;
    return 0;
}

函数指针的使用：

#include<iostream>
// 函数声明， 比对1中的 int num = 20;
int add(int a, int b);
int main()
{
    // 函数指针的声明， 比对 1 中的 int * p;
    int (*pFunc)(int, int);
    // 指向函数的地址，（函数的名字就是函数的地址）
    pFunc = add;
    // 打印结果， 比对 1 中的打印， 仅仅是多了一个参数列表
    std::cout << (*pFunc)(2, 3) << std::endl;
    return 0;
}

int add(int a, int b)
{
    return a + b;
}

指针函数的使用：

int * sum(int x); //指针函数的声明；返回类型为一个指针变量 可以通过*p来获取值
int * sum(int x){        //指针函数的定义
    int static sum =0;   //static 修身的变量在数据段；不会被函数栈回收
    int *p;
    int i;
    for(i=1;i<=x;i++){
        sum +=i;
    return p;     //返回类型是某一类型的指针   注意这里，返回的是指针，用int*来接收
    }
 
int *p1;
p1 = fun(a);      //指针函数的调用

三、typedef 定义函数指针介绍

3.1 typedef与define比较？

相同点：typedef 的行为有点像#define宏，用其实际类型替代同义字
不同点：typedef在编译时被解释，因此让编译器来应付超越预处理器能力的文本替换

3.2 typedef 的用法

typedef主要为起别名，类似于给你起个小名。用法：typedef 原变量类型别名

首先来看看为结构体起别名

typedef struct StudentT{
    int id;
    int name;
}Student;   //这里Student为别名，如果不加typedef，这个Student为结构体实例，注意区别
// 此时， 我们就可以使用Student来定义该结构体的实例了。
Student student_one;  //而不用繁索的写 struct StudentT student_one；

我们为一个指针起别名

#include "iostream"
using namespace std;

typedef int * IntPtr;
int main()
{
  IntPtr x = new int(6);
  cout << x << " " << *x << endl;
  
  system("pause");
  return 0;
}

那我们用来为函数指针起别名：

typedef int (*PFUN)(int, int);

没看懂把~ 看看下面：

typedef int(*)(int, int) PFUN; // 你好像不能这么去写， 不过可以这么去看。所以还是要按照上面的方式去写

我们可以解释为：这个声明引入了 PFUN 类型作为函数指针（参数：两个int类型，返回值：int）的别名。用typedef 为函数指针起别名。相当于 typedef int(*)(int, int) PFUN

typedef int(*FPUN)(int, int);
int add(int a, int b);

int main()
{
    // 函数指针的声明 int(*PFUN)(int, int) ==> int(*pFunc)(int, int)
    PFUN pFunc;    //函数名和数组名实际上都不是指针，但是，在使用时可以退化成指针
    pFunc = add;
    std::cout<< (*pFUnc)(2, 3) << std::endl;
    return 0;
}

int add(int a, int b)
{
    return a + b;
}

接下开看一个案例：嵌套的函数指针类型，并将指针作为返回值。

#include <iostream>
using namespace std;
#include <stdio.h>

// 为函数指针起一个别名PFUN  函数指针指向返回类型为int, 参数为两个int 的函数
typedef int(*PFUN)(int, int);

int add(int a, int b);
int sub(int a, int b);
int mul(int a, int b);
int div1(int a, int b);

// 声明一个函数， 用函数指针PFUN做返回值， 所以该函数可以说是指针函数
PFUN calc_func(char op);

int calculate(int a, int b, char op);

int main()
{
	int a = 100, b = 5;
	printf("calculate(%d, %d, %c) = %d\n", a, b, '+', calculate(a, b, '+'));
	printf("calculate(%d, %d, %c) = %d\n", a, b, '-', calculate(a, b, '-'));
	printf("calculate(%d, %d, %c) = %d\n", a, b, '*', calculate(a, b, '*'));
	printf("calculate(%d, %d, %c) = %d\n", a, b, '/', calculate(a, b, '/'));
	return 0;
}

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 div1(int a, int b)
{
	return a / b;
}

// 判断输入的字符op， 返回不同的函数地址 （函数的地址就是函数名字）
PFUN calc_func(char op)
{
	switch (op)
	{
	case '+': return add;
	case '-': return sub;
	case '*': return mul;
	case '/': return div1;
	default:
		return NULL;
	}
	// 指针可以指向空啊， 所以函数指针也可以
	return NULL;
}

int calculate(int a, int b, char op)
{
	// 既然calc_func这个函数的返回类型是函数指针类型， 那我们就用一个函数指针来接返回值
	PFUN pFunc = calc_func(op);
	if (pFunc)
	{
		return pFunc(a, b);
	}
	return -1;
}