5.6 C面向接口编程和C多态

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

//数组指针 语法 梳理
//定义一个数组类型


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

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

void main01()
{
	int a[10];//a代表数组首元素的地址 &a代表整个数组的地址 a+1 4  &a 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;
		(*myPArray)[0] = 20;

		printf("a[0]: %d \n", a[0]);
	}
	//定义一个指向 数组类型的指针 数组类的指针
	{
		int(*myPointer)[10];//变量 告诉c编译器 给我分配内存
		myPointer = &a;
		(*myPointer)[0] = 40;

		printf("a[0]: %d \n", a[0]);
	}
	printf("hello...\n");
	system("pause");
	return;
}
//函数指针语法梳理
//1 如何定义一个函数类型
//2 如何定义一个函数指针类型
//3 如何定义一个 函数指针  (指向一个函数的入口地址)
int add(int a, int b)
{
	printf("func add...\n");
	return a + b;
}
void main()
{
	add(1, 2);//直接调用 函数名就是函数的入口地址

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

		myPointerFunc = &add;//细节1 
		myPointerFunc(3, 4);//间接调用

		myPointerFunc = add;//细节1  这里取地址 不取地址都可以 是c逐渐完善起来的
		myPointerFunc(3, 4);//间接调用
	}
	//定义一个 函数指针类型
	{
		typedef int(*MyPointerFuncType)(int a,int b);//int *a=null
		MyPointerFuncType myPointerFunc;//定义一个函数指针
		myPointerFunc = add;
		myPointerFunc(5,6);
	}
	//定义一个 函数指针
	//函数指针
	{
		int(*MyPonterFunc)(int a, int b);//定义一个变量
		MyPonterFunc = add;
		MyPonterFunc(7, 8);
	}

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

5.6.1函数类型语法基础

数组指针和函数指针两个都有三种用法，形式也类似

1、定义一个数组类型

2、定义一个数组指针类型

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

函数指针基本语法梳理

1、如何定义一个函数类型

2、如何定义一个函数指针类型

3、如何定义一个函数指针（指向一个函数的入口地址）

函数三要素： 名称、参数、返回值 C语言中的函数有自己特定的类型

C语言中通过typedef为函数类型重命名 typedef type name(parameter list) typedef int f(int, int); typedef void p(int);

函数指针

函数指针用于指向一个函数 函数名是函数体的入口地址 1)可通过函数类型定义函数指针: FuncType* pointer; 2)也可以直接定义：type (*pointer)(parameter list); pointer为函数指针变量名 type为指向函数的返回值类型 parameter list为指向函数的参数类型列表

函数指针语法梳理 //函数类型 //函数指针类型 //函数指针变量   数组指针语法梳理  //数组类型语法 //数组指针类型 //数组指针变量

5.6.2函数指针做函数参数

1、  指针做函数参数pk函数指针做函数参数 回忆指针做函数参数 一级指针做函数参数、二级。。。。、三级

2、  函数指针做函数参数 当函数指针 做为函数的参数，传递给一个被调用函数， 被调用函数就可以通过这个指针调用外部的函数，这就形成了回调

结论：回调函数的本质：提前做了一个协议的约定（把函数的参数、函数返回值提前约定）

请思考：C编译器通过那个具体的语法，实现解耦合的？

         C++编译器通过多态的机制(提前布局vptr指针和虚函数表,找虚函数入口地址来实现)

#define  _CRT_SECURE_NO_WARNINGS 
#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 add2() do...\n");
	return a + b;
}
int myadd3(int a, int b)  //子任务的实现者
{
	printf("func add3() do...\n");
	return a + b;
}
int myadd4(int a, int b)  //子任务的实现者
{
	printf("func add4() do...\n");
	return a + b;
}

//定义一个 函数指针类型
//函数指针类型  把函数的参数，函数的返回值 做好提前的约定
typedef int(*MyTypeFuncAdd)(int a, int b);

//函数指针 做函数参数
int MainOp(MyTypeFuncAdd myFuncAdd)
{
	int c = myFuncAdd(5,6);
	return c;
}
//函数指针
// int (*MyPointerFuncAdd)(int a, int b)
int MainOp2(int(*MyPointerFuncAdd)(int a, int b))
{
	int c = MyPointerFuncAdd(5, 6); //间接调用
	return c;
}

//间接调用
//任务的调用 和任务的编写可以分开
void main()
{
	//定义一个函数指针类型
	MyTypeFuncAdd myFuncAdd = NULL;
	myadd(1,2);//直接调用

	myFuncAdd = myadd;
	myFuncAdd(3,4);
	//函数指针做函数参数 
	MainOp(myadd);
	MainOp2(myadd);
	
	//在MainOp框架 没有发生任何变化的情况下
	MainOp(myadd);
	MainOp(myadd2);
	MainOp(myadd4);
	
	printf("hello...\n");
	system("pause");
	return;
}