C语言：以函数为核心 数组 指针 函数结构体之间的关系

一、什么是函数？

1、组成：
返回值类型 名字(形参)
{
函数体;
return 返回值;
}

2、名字 : 就是函数的首地址 (指针类型)
3、形参 ：传参： 值传递 址传递
4、函数体：在花括号内的可执行语句
5、返回值类型 与 return 返回值 相呼应 ;
6、函数调用：
函数名字(实参); // 函数指针(实参);

二 函数与数组之间的关系：

1、 数组作为形参

    int arr[10];            // arr : int *
    fun(arr);
    ==============>
            fun(int *p)
            fun(int p[])
            fun(int p[10])
            ---> 以上三种形式，其实就是 一种 形式： int *p

例子： 
    int main(int argc,char *argv[])   char *argv[]：char **argv 
    int main(int argc,char **argv)

2、多维数组：

        int arr[2][3][4];            // int (*)[3][4]
        int arr[][3][4] ={{},{}};        
        fun(arr);
        -=======================>
                fun(int (*p)[3][4])
                fun(int p[][3][4])
                fun(int p[2][3][4])
                    
        
    int arr[2][3][4];   //  {int [3][4]} {int [3][4]}

// *arr // int [3][4]
int brr[3][4];
fun(*arr)
===========================>
fun(int (*p)[4])
fun(int p[][4])
fun(int p[3][4])

int brr[3][4][5][6][7][8][9]; {int [4][5][6][7][8][9]} {int [4][5][6][7][8][9]} {}
fun(brr);
===========>
fun(int (*p)[4][5][6][7][8][9])

3、 数组作为函数体

    多维数组： 
        fun(void)
        {
            int arr[2][3][4];
        }

4、数组作为返回值

    一维数组作为返回值：
    int * fun(void)
    {
        int arr[10];
        return arr;
    }
    ====? 写法没有问题，但是程序有问题 
    
int *p = fun();
修改：
    int * fun(void)
    {
        // static int arr[10];
        int *arr = (int *)malloc(20);
        return arr;
    }

    多维数组 作为返回值：
    int (*fun2(void))[5][6]
    {
        static int arr[4][5][6];
        return arr;
    }

======================

三、函数与指针之间的关系：

* 指针作为形参

    int a = 10;
    int *p = &a;
    fun(p);
    ==============>
            fun(int *pp)
            fun(int pp[])
            fun(int pp[10])
            =============> 本质都是  int *

* 多级指针作为形参：

    int a = 10;
    int *p = &a;
    int **pp = &p;
    int ***ppp = &pp;
    fun(ppp);
    ============> 
            fun(int ***x)
            fun(int **x[])
            fun(int **x[10])
                ====》  本质 ：都是  int *** 

* 指针作为函数体：

    void fun(void)
    {
        int *****xx;
    }

* 指针作为返回值 ：

    int *fun(void)
    {
        static int a;
        int *p = &a;
        return p;
    }

* 多级指针作为返回值：

    int ***fun(void)
    {
        int a;
        int *p = &a;
        int **pp = &p;
        int ***ppp = &pp;
        return ppp;
    }

======================

四、函数与函数之间的关系：

* 函数作为形参：

    ====》 回调函数 
    void xx(int a){}      // xx :  void (*)(int)
    fun(xx);
        =======>    
            fun(void (*p)(int)){}

* 函数作为函数体：

只能函数调用，不能在函数里面定义函数
函数的调用：
void xx(void){}

        fun(void)
        {
            xx();
        }

* 函数作为返回值 ：

typedef void (*sighandler_t)(int);        
sighandler_t signal(int signum, sighandler_t handler);    

例子：
void fun(short a,char c){}
int (*p)(void) = test(fun);

请问： test函数如何书写？？
int(*test(void (*p)(short,char)))(void)
{

}


int (*p)(void) = test();
int (*test(void))(void)
{
    
}

int (*f(void))(int){
return fun;
}

int ((*pfun)(int ))[10];
解答：
int ()[10] ()(int ) pfun ;
xx ()(int *) pfun; // 返回值为 xx 形参为 int * 函数指针变量 pfun

int ()[10] ：

Y (*)[10] 数组指针 // 指向 int * [10]

int *(*fun(int *x))[10]      fun : 类型： int *(*(*)(int *))[10]   
{
    static int *arr[3][10];
    return arr;    
}

int *(*(*p)(int *))[10]  = fun;

int (*func1)(int *p, int (*f)(int ));
int ((*func3)[5])(int pInt);
int ((*func4)(int *pInt))[5];

======================

五、函数与结构体之间的关系：

* 结构体作为形参：

    struct point{int x;int y;} xx;
    fun(xx);
    ====================>
            fun(struct point sp){}

* 结构体作为函数体

    fun(void)
    {
        struct point{int x;int y;} xx;
    }

* 结构体作为返回值：

    struct point fun(void)
    {
        struct point{int x;int y;} xx;
        return xx;
    }

    int fun(void)
    {
        int a = 10;
        return a;
    }