day12

1.函数指针

指针。保存函数的地址。这个指针指向的是一类函数
函数：
      数据类型   函数名(形参列表)；  
       
函数指针：
      数据类型   (*函数指针名)(形参列表)

int  add(int x , int y)
{
return x + y;        
}
int sub(int x, int y)
{
   return x - y;
}
       
//函数指针指向某个函数
int (*p)(int x, int y);
p = add;
p = ⊂
//函数指针调用函数
指针名(实参)；
p(10 , 20);
(*p)(10, 20);  

2.函数指针数组

是一个数组。每一个元素都是一个函数指针
一般形式：
      数据类型 (*函数指针数组名[元素个数]) (形参列表)；

int add(int x, int y)
{
   return x + y;
}
int sub(int x, int y)
{
   return x - y;
}
int main(int argc, char *argv[])
{
   int (*p[2])(int x, int y);
   p[0] = add;
   p[1] = sub;
   printf("%d\n", p[0](10, 20));
   printf("%d\n", p[1](10, 20));
   return 0;
}

3.递归函数

递归：是一个思想，用解决递归问题、回溯思想的问题
    栈
 
    递归函数：是一个函数，函数自己调用自己。
(1)设计调用结束的条件
    (2)递归函数代码简单 ,提高理解难度，增加资源开销 

应用实例

实现数字阶乘

int  fact(int num)
{
    if(num > 1)
    {
       return num * fact(num - 1);
    }
    else
    {
        return 1;
    }
}

（需要调用的函数，主函数为main函数）

4.回调函数

函数指针
   funcA  funcB，  函数A中的参数有一个为函数指针，
   此时如果把函数B的地址，作为参数传入函数A中， 函数A就具备调用函数B的能力，
   如果在特定情况下，函数A中调用了函数B， 那么函数B就叫回调函数    
   主调函数：funcA
   被调函数：funcB    
       
 
   作用：  1.实现泛型、多态编程
          2.实现减少重复的代码
          3.隐藏实现  

实现qosrt

#include <stdio.h>
#include <string.h>

#define N1 10
#define N2 5

int com_Int(const void *a, const void *b) // 姣旇緝涓や釜鏁扮殑澶у皬
{
    int arg1 = *(const int *)a;
    int arg2 = *(const int *)b;

    if (arg1 < arg2)
        return -1;
    if (arg1 > arg2)
        return 1;
    return 0;
}

int com_Double(const void *a, const void *b)
{
    double arg1 = *(const double *)a;
    double arg2 = *(const double *)b;

    if (arg1 < arg2)
        return -1;
    if (arg1 > arg2)
        return 1;
    return 0;
}

int swap(void *a, void *b, int size)
{
    char temp[size];
    memcpy(temp, a, size);
    memcpy(a, b, size);
    memcpy(b, temp, size);
}

int arr_sort(void *arr, int num, int num_size, int (*p)(const void *a, const void *b))
{
    char *q = (char *)arr;

    int i, j;
    for (i = 0; i < num - 1; i++)
    {
        for (j = 0; j < num - 1 - i; j++)
        {
            if (p(arr + j * num_size, arr + (j + 1) * num_size) < 0)
            {
                swap(arr + j * num_size, arr + (j + 1) * num_size, num_size);
            }
        }
    }
}

/
int prtint_int(void *a)
{
    printf("%d\t", *(int *)a);
    return 0;
}

int prtint_double(void *a)
{
    printf("%.2f\t", *(double *)a);
    return 0;
}

int arr_show(void *arr, int num, int num_size, int (*print)(void *))
{
    int i;
    char *p = (char *)arr;

    for (i = 0; i < num; i++)
    {
        print(p + i * num_size);
    }
    puts("");

    return 0;
}

int main(int argc, char *argv[])
{
    int A[N1] = {11, 20, 99, 100, 50, 200, 900, -2, 3, 6};
    double B[N2] = {10.1, 72.2, 3.3, 14.4, 95.5};

    printf("int show ---------- \n");
    arr_show(A, N1, sizeof(int), prtint_int);
    arr_sort(A, N1, sizeof(int), com_Int);
    arr_show(A, N1, sizeof(int), prtint_int);

    printf("double show ---------- \n");
    arr_show(B, N2, sizeof(double), prtint_double);
    arr_sort(B, N2, sizeof(double), com_Double);
    arr_show(B, N2, sizeof(double), prtint_double);

    return 0;
}

回调函数是一个很高级的函数，代码也相对较长，在后续中还会继续学习了解。