• 函数指针基本语法知识梳理
• 1.如何定义一个函数类型
• 2.如何定义一个函数指针类型
• 3.如何定义一个 函数指针指向一个函数的入口地址

#include <iostream>
using namespace std;
//数组类型的基本语法
//定义一个数组类型
//int a[10];
//定义一个指针数组类型

//定义一个指向数组类型的指针  数组指针


void main01(){
	int a[10];//a代表的数组首元素的地址 &a代表整个数组的地址
	//a+1  4和&a+1 40步长不一样

	//定义一个数组类型
	{
		typedef int(myTypeArray)[10];
		myTypeArray myArray;
		myArray[0] = 10;
		printf("%d\n",myArray[0]);
	}

	//定义一个指针数组类型
	typedef int (*PTypeArray)[10]; // int *p

	PTypeArray myPArray;//sizeof(int) *10

	myPArray = &a;
	//int b = 10;
	//int *p = NULL;
	//p = &b;
	(*myPArray)[0] = 20;

	printf("%d\n",a[0]);

	{
		//定义一个指向数组的指针  数组类的指针

		int (*MyPointer)[10];//这不是数据类型，这是变量
		//告诉编译器，预分配内存
		MyPointer = &a;
		*MyPointer[0] = 40;
		printf("%d\n",a[0]);
	}

	cout<<"hello"<<endl;
	system("pause");
	return ;
}

int add(int a,int b)
{
	printf("func add()\n");
	return a+b;

}
void main02(){
	add(1,2);//直接调用  //函数名就是函数的入口

	//定义一个函数类型
	{
		typedef int (MyFuncType)(int a,int b);//定义了一个类型
		MyFuncType *myPointerFunc = NULL;//定义了一个指针
		//指向某一种类的函数，两个参数，int返回值

		myPointerFunc  = &add;

		myPointerFunc(3,4);//间接调用

		myPointerFunc  = add;//兼容历史版本
		myPointerFunc(5,6);
	}

	//定义一个函数指针类型
	{
		typedef int(*MyPointerFuncType)(int a,int b);
		//int *a = NULL;
		MyPointerFuncType mypointerfunc;//定义一个指针
		mypointerfunc = add;
		mypointerfunc(7,8);

	}
	//函数指针
	{
		int (*MyPonterFunc)(int a,int b);//定义了一个变量
		MyPonterFunc = add;
		MyPonterFunc(10,11);
	}


	system("pause");
}

---

• 函数指针类型起到的作用：

把函数的参数，函数的返回值提前约定

#define _CRT_SECURE_NO_WARINGS
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

int myadd(int a,int b ){      //理解为多个厂商的实现
	printf("func add() do..\n");
	return a+b;
}
//采用这种方法
//可以在不改变原来框架的基础上调用起来后来人的代码
//简单的问题复杂化，很有助于以后框架的拓展和维护
int myadd2(int a,int b ){
	printf("func add() do..\n");
	return a+b;
}
int myadd3(int a,int b ){
	printf("func add() do..\n");
	return a+b;
}
int myadd4(int a,int b ){
	printf("func add() do..\n");
	return a+b;
}


typedef int (*MyTypeFuncAdd)(int a,int b);//定义了一个类型

//间接调用
//函数指针做函数参数
int MainOp01(MyTypeFuncAdd MyTypeFuncAdd)
{
	int c = MyTypeFuncAdd(5,6);
	return c;

}
//定义一个指向某种类型的指针，可以做函数参数
int MainOp02(int (*MyPointerFuncAdd)(int a,int b))
{
	int d = MyPointerFuncAdd(5,6);
	return d;
}


void main()
{	
	MyTypeFuncAdd myfuncadd = NULL;
	myfuncadd = myadd;
	myadd(1,2);
	myfuncadd(3,4);//间接调用

	MainOp01(myadd);
	MainOp02(myadd);
	MainOp01(myadd2);
	MainOp02(myadd3);


	printf("hello...\n");
	system("pause");
	return ;

}

---

• 函数指针做函数参数在工程中的作用
• 可以实现动态库的正向调用和逆向调用
• 问题：如果是c语言的话，怎么实现类似mainop（）这种框架呢？
  • 1.在动态库的内部，需要提前定义好一套接口（函数指针类型的定义）
  • 2.在动态库的外部，发布一套接口协议（发布.h文件）
  • 3.厂商根据你的.h  实现函数原型（编写子任务）
  • 4.把厂商函数的入口地址注入到框架中
  • 5.在框架中，回调第三方厂商编写的任务实现方法