37 C面向接口编程和多态

1 数组指针类型

//定义一个数组类型
//int a[10];

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

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


void main(){
	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
		printf("sizeof(myPArray) %d \n", sizeof(myPArray));
		myPArray = &a;
		(*myPArray)[0] = 20;
		printf("%d \n", a[0]);

	}

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

2 函数指针类型

//函数指针语法
// 1定义一个函数类型
// 2定义一个函数指针类型
// 3定义一个函数指针 指向函数的入口地址

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

void main() {
	add(1, 2);	// 直接调用，函数名就是函数的入口地址

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

		myPointerFunc = &add;	//
		// myPointerFunc = add;	//不加取地址也能通过
		myPointerFunc(3, 4);	// 间接调用
	}

	{
		// 2定义一个函数指针类型
		typedef int (*MyPointerFuncType)(int a, int b);	// int *a = NULL;
		MyPointerFuncType myPointerFunc;	// 定义一个指针
		myPointerFunc = add;
		myPointerFunc(5, 6);
	}
	{
		// 3定义一个函数指针 指向函数的入口地址
		int (*MyPointerFunc)(int a, int b);	// 定义一个变量
		MyPointerFunc = add;
		MyPointerFunc(7, 8);
	}
}

3 函数指针做函数参数

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

int myadd(int a, int b) {	//子任务实现
	printf("func add ...\n");
	return a + b;
}

int myadd2(int a, int b) {	//子任务实现
	printf("func add2 ...\n");
	return a + b;
}

int myadd3(int a, int b) {	//子任务实现
	printf("func add3 ...\n");
	return a + b;
}

int myadd4(int a, int b) {	//子任务实现
	printf("func add4 ...\n");
	return a + b;
}

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

// 函数指针做函数参数
int MainOp(MyTypeFuncAdd myFuncAdd) {
	int c = myFuncAdd(5, 6);
	return c;
}

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(myadd2);
	MainOp(myadd3);
	MainOp(myadd4);

}