第四个没必要花时间去弄，顶多是面试的时候能看见，这个答不出来也无所谓，因为实际工作根本用不上。还有那些超多重的指针或者数组那些，顶多弄明白三重就差不多了。过于复杂的真心没必花大量时间去弄明白，以前我也钻过这样的牛角尖，现在工作才知道，钻通了也用不上

[此贴子已经被作者于2016-12-23 16:23编辑过]

收到的鲜花

• azzbcc 于 2016-12-23 16:38 送鲜花  10朵   附言：我很赞同

哇，楼主竟然还遇到过三重指针~我好像也有用~给个你看看~
再更新玩玩看~玩玩而已~
typedef void (*COM)();

COM (*p)[3]=a;

这是我用来做多级菜单用的

指针数组就是两重指针，再叠加个指针函数，如果函数返回值还是个指针类型，就可以做四重指针了~

这是我用指针函数的实验模板，拿出来分享一下~

没啥功能实现，就是玩玩变量名称~

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int fun_0_0();
    int fun_0_1();
    int fun_0_2();
    int fun_1_0();
    int fun_1_1();
    int fun_1_2();
    int fun_2_0();
    int fun_2_1();
    int fun_2_2();

    int ss=0;

    typedef int (*COM)();

    COM a[][3]=
    {
        {fun_0_0,fun_0_1,fun_0_2},
        {fun_1_0,fun_1_1,fun_1_2},
        {fun_2_0,fun_2_1,fun_2_2},
    };

    COM (*p)[3]=a;

    while (1)
    {
        char cmd=0;

        system("cls");

        ss=(*(*(p+ss)+2))();

        cmd=getch()-'0';

        if (cmd<0||cmd>sizeof(a[0])/sizeof(void *)-2)
            continue;
        
        ss=(*(*(p+ss)+cmd))();
        fflush(stdin);
    }

}
int fun_0_0()
{
    exit(0);
}
int fun_0_1()
{
    return 1;
}
int fun_0_2()
{
    printf("这里是导航菜单0\n");
    printf("请输入:\n");
    printf("1:切换到菜单1\n");
    printf("0:退出程序\n");
    return 0;
    
}
int fun_1_0()//
{
    return 0;
}
int fun_1_1()
{

    return 2;

}
int fun_1_2()
{
    printf("这里是导航菜单1\n");
    printf("请输入:\n");
    printf("1:切换到菜单2\n");
    printf("0:切换到菜单0\n");
    return 1;
}
int fun_2_0()
{
    return 0;
}
int fun_2_1()
{
    return 1;
}
int fun_2_2()
{
    printf("这里是导航菜单2\n");
    printf("请输入:\n");
    printf("1:切换到菜单1\n");
    printf("0:切换到菜单0\n");
    return 2;
}

[此贴子已经被作者于2016-12-24 07:33编辑过]

这些自己做来耍耍还可以，真要做了开发了，估计要给人活生生揍死。

没办法，水平有限~自己无聊做来玩玩~

偶然看到的

分析指针，可以从变量名处起,根据运算符优先级结合,一步一步分析.
int p;   //这是一个普通的整型变量
int *p;   //首先从P处开始,先与*结合,所以说明P是一个指针,然后再与int结合,说明指针所指向的内容的类型为int 型.所以 P是一个返回整型数据的指针
int p[3];   //首先从P处开始,先与[]结合,说明P 是一个数组,然后与int结合,说明数组里的元素是整型的,所以 P是一个由整型数据组成的数组
int *p[3];   //首先从P处开始,先与[]结合,因为其优先级比*高,所以P是一个数组,然后再与*结合,说明数组里的元素是指针类型,然后再与 int结合,说明指针所指向的内容的类型是整型的,所以是一个由返回整型数据的指针所组成的数组
int (*p)[3];   //首先从P处开始,先与*结合,说明P是一个指针然后再与[]结合(与"()"这步可以忽略,只是为了改变优先级),说明指针所指向的内容是一个数组,然后再与int 结合,说明数组里的元素是整型的.所以P是一个指向由整型数据组成的数组的指针
int **p;   //首先从 P开始,先与*结合,说明P是一个指针,然后再与*结合,说明指针所指向的元素是指针,然后再与 int结合,说明该指针所指向的元素是整型数据. 所以P是一个返回指向整型数据的指针的指针
int p(int);   //从P处起,先与()结合,说明P是一个函数,然后进入()里分析,说明该函数有一个整型变量的参数然后再与外面的int 结合,说明函数的返回值是一个整型数据.所以P是一个有整型参数且返回类型为整型的函数
int (*p)(int);   //从P处开始,先与指针结合,说明P是一个指针,然后与()结合,说明指针指向的是一个函数,然后再与()里的int 结合,说明函数有一个int 型的参数,再与最外层的int 结合,说明函数的返回类型是整型,所以P是一个指向有一个整型参数且返回类型为整型的函数的指针
int *(*p(int))[3];   //从 P开始,先与()结合,说明P是一个函数,然后进入()里面,与int结合,说明函数有一个整型变量参数,然后再与外面的*结合,说明函数返回的是一个指针,,然后到最外面一层,先与[]结合,说明返回的指针指向的是一个数组,然后再与*结合,说明数组里的元素是指针,然后再与int 结合,说明指针指向的内容是整型数据.所以P是一个参数为一个整数且返回一个指向由整型指针变量组成的数组的指针变量的函数

收到的鲜花

• bjut_Allen 于 2016-12-24 15:09 送鲜花  5朵   附言：好文章

。看不懂

最后一个相当于

    typedef int *COM[3];
    COM *fun(int);

这样分开来看就清晰很多了~

可以看出，int *(*p(int))[3];

是一个返回一个指针值的函数，该函数的返回指针指向为一个大小为3的数组指针~

无聊想弄清楚最后一个有什么功能~结果发现函数里面只是一个int形参，而返回值却是一个指向一个数组指针的指针，除了想到用全局变量来辅助外实现其功能外，似乎没有什么办法来体现其功能了~
感觉有些复杂的变量无聊拿来玩玩可以，真是要看看有什么实用价值就要烧脑了~

以下是我对一些比较复杂的变量测试的代码~

#include <stdio.h>
int a[3]={1,2,3};
int *p[3]={&a[0],&a[1],&a[2]};
int *k[3]={&a[2],&a[1],&a[0]};
int main()
{
    int a[3]={1,2,3};
    int *p[3]={&a[0],&a[1],&a[2]};
    int *(*s)[3]=NULL;
    int i=0;
    int *(*fun(int))[3];
    s=fun(1);
    for (i=0;i<3;i++)
        printf("%d ",*(*s)[i]);
    s=fun(0);
    printf("\n");
    for (i=0;i<3;i++)
        printf("%d ",*(*s)[i]);
    printf("\n");

    return 0;
}
int *(*fun(int ff))[3]
{
    if (ff)
        return &p;
    else
        return &k;
}