C进阶（指针）

一维数组传参的几种形式（5种）

void test(int arr[])//
{}
void test(int arr[10])//
{}
void test(int *arr)//
{}
void test2(int *arr[20])//
{}
void test2(int **arr)//
{}

int main()
{
 int arr[10] = {0};
 int *arr2[20] = {0};
 test(arr);
 test2(arr2);
}

二维数组传参的几种形式

1. 二维数组的传参，函数形参的设计只能省略一个[]的数字。即必须知道一行有多少元素。

void test(int arr[3][5]);
void test(int arr[][5]);
void test(int (*arr)[5])

int main()
{
	int arr[3][5]={0};
  test(arr);
}

函数指针

1. 函数名就是函数的入口地址 , 两者打印结果一致

void fun()
{}
void main()
{
	printf("%p\n",fun);    //  输出结果一致
  printf("%p\n",&fun);
}

2. 定义函数指针调用形式

void fun(int a, char *s)
{}
void main()
{
	void(*pfun)(int, char*)=&fun;	  //  标准写法
  (*pfun)();
	void(*pfun)(int a, char *s)=fun;    //  简化写法
  pfun();
}

指向函数指针数组的指针

1. 是一个指针。指针指向一个数组，数组里的元素都是函数指针

int(*(*a)[5])(int)
void test(const char* str){}
void main()  
{
//  指向函数的指针
 void (*pfun)(const char*) = test;
 //  指向函数的指针数组
 void (*pfunArr[5])(const char* str);
 //  指向函数指针数组的指针
 void (*(*ppfunArr[5])(const char*) = &pfunArr;
}

回调函数

通过函数指针调用的函数。把函数的指针（地址）作为参数传递给另一个参数，当这个指针被用来调用其所指向的函数时，称为回调函数。

int Max(int a, int b){return a>b?a:b}
int Find(int a, int b, int(*pfun)(int, int)){return pfun(a,b);}
void main() 
{
	int a=10; int b =20;
  //int max_value = Max(a,b);
  int value = Find(a,b,Max);  //  回调函数
}

知识积累：

1. 函数强转

(*(void(*)())0)()     //   将0强制转换为函数指针，再进行调用

2. typedef使用

int * (* (*fun)(int *))[10]
typedef int* (*Ar_t)[10];  
Ar* (*fun)(int *); //简化形式 
// 指向函数返回值为数组指针的函数指针，其中函数指针的参数为整形指针
// 加了typedef  是定义一个类型  不加直接定义一个数组
void main()
{
	Ar a;
}

3. 程序分析

程序简写   
void (*signal(int, void(*)(int)))(int)   //  简写
typedef void(*PFun_t)(int)
PFun_t signal(int, PFun_t PF)

转移表
int Mod(int a, int b){}; int Mut(int a, int b){};
int(*fun_table[])(int, int) = {NULL, Mod, Mut};
int select, a, b; scanf("%d %d %d", &select,&a,&b);
int result = fun_table[select](a, b);

4. 快排函数的使用(qosrt)

 整形数据的排序，字符串排序, 结构体排序（根据结构体中的某一个元素）

#include<stdio.h>
#include<stdlib.h>
qosrt(void *base, size_t num, size_t width, 
int (*compare)(const void *elm1, const *elm2))

使用冒泡排序模拟快排