c语言是面相接口编程吗,二十、C语言中的面向接口编程（回调函数）

函数三要素：名称、参数、返回值

思考：

如何定义一个数组类型？

如何定义一个数组指针？

//方法一

//定义一个数组类型

typedef int(ARRAY_INT_10_TYPE)[10];

//方法二

//直接定义一种数组指针

typedef int(*ARRAY_INT_10_TYPE_POINTER)[10];

int main(void)

{

int array[10];

ARRAY_INT_10_TYPE array2;

ARRAY_INT_10_TYPE *array_p = NULL;//指向数组类型的指针

ARRAY_INT_10_TYPE_POINTER array_p3 = NULL;

*array; //数组第一个元素int,array是数组的名字，首元素的地址

//是一个存放int数组的第一个元素

*array_p;//理解为存放数组的数组名！

//是一个存放数组的数组的第一个元素

for(int i = 0;i<10;i++){

(*array_p)[i] = 10;

}

for(int i = 0;i < 10;i++){

array[i] = 10;

array2[i] = 10;

}

return 0;

}

1.函数类型语法基础

函数指针用于指向一个函数, 函数名是函数体的入口地址

可通过函数类型定义函数指针: FuncType* pointer;

也可以直接定义：type (*pointer)(parameter list);

pointer为函数指针变量名

type为指向函数的返回值类型

parameter list为指向函数的参数类型列表

//定义一个函数

int func(int a,int b){

cout<

}

//定义一个函数指针

//C语言中决定一个函数类型

//返回值参数列表

typedef int(FUNC)(int ,int);//定义一个函数类型

typdef int(*FUNC_POINTER)(int,int);//定义一个函数指针类型

//当函数指针做为函数的参数，传递给一个被调用函数

//被调用函数就可以通过这个指针调用外部的函数

//这就形成了回调。

//如何将一个函数指针当做一个函数参数呢？

void my_function(FUNC *fp)

{

fp(10,20);

}

void my_function2(FUNC_POINTER fp)

{

fp(10,20);

}

//它是一个架构函数(和多态一样！)

void my_function3(int(*fp)(int,int))

{

cout<

cout<

fp(10,20);

cout<

}

//2015年实现一个子函数

int my_new_function(int a,int b)

{

cout<

cout<

return 0;

}

int main(void)

{

FUNC *p = func;

FUNC_POINTER p2 = func;

int (*fp)(int ,int) = func;

p(10,20);

(*p)(10,20);//以上两种写法等价

p2(10,20);

(*p2)(10,20);

fp(10,20);

//2015年 实现一个子函数，再调用1999年的架构

my_function3(my_new_function);

//my_new_function 相当于int (*p)(int ,int)= my_new_function;

//所以这里的my_new_function不需要写参数！

return 0;

}

2回调函数的优点

函数的调用 和 函数的实现 有效的分离

类似C++的多态,可扩展

现在这几个函数是在同一个文件当中

int libfun(int (*pDis)(int a,intb))

是一个库中的函数，就只有使用回调了，通过函数指针参数将外部函数地址传入来实现调用。

函数 add 的代码作了修改，也不必改动库的代码，就可以正常实现调用便于程序的维护和升级。

//定义一个锦囊的方法，是一个指针，类似于C++的纯虚函数

typedef void(TIPS_FUNC)(void);

//写一个锦囊的结构体

struct tips

{

char from[64];//这个锦囊是谁写的

char to[64]; //写给谁的

TIPS_FUNC *fp; //具体锦囊的内容

}

//写一个供调用的架构函数

void open_tips(struct tips *tp)

{

cout<

cout<from<to<

cout<

tp->fp();//拆开锦囊，调用具体的方法

}

//实现一个锦囊,类似于实现一个纯虚函数

void tips_1(void)

{

cout<

}

void tips_2(void)

{

cout<

}

void tips_3(void)

{

cout<

}

void tips_4(void)//新加！！

{

cout<

}

struct tips * create_tips(char *from,char *to,TIPS_FUNC *fp)

{

struct tips *tp = (struct tips*)malloc(sizeof(struct tips));

if(tp == NULL)return -1;

strcpy(tp->from,from);

strcpy(tp->to,to);

//注册回调函数

tp->fp = fp;//给拥有函数指针的结构体 函数指针变量赋值 就是 注册回调函数

return tp;

}

void destory_tips(struct tips *tp)

{

if(tp != NULL)free tp;

}

int main(void)

{

//孔明写锦囊

struct tips *tp1 = create_tips("孔明","赵云",tip_1);

struct tips *tp2 = create_tips("孔明","赵云",tip_2);

struct tips *tp3 = create_tips("孔明","赵云",tip_3);

struct tips *tp4 = create_tips("庞统","赵云",tip_4);

//赵云拆锦囊

open_tips(tp1);

open_tips(tp2);

open_tips(tp3);

open_tips(tp4);

destory_tips(tp1);

destory_tips(tp2);

destory_tips(tp3);

destory_tips(tp4);

return 0;

}

1.png

回调函数的本质:

提前做了一个协议的约定(把函数的参数、函数返回值提前约定)