【大牛】大牛给指针，极难

【问题】 2015/7/3 14:29:49
typedef struct T{ union { struct T* (*v)(const *[]); const * const r; };}const*(*(*(*(*v)[1])[1])(struct { const c;}*(*)(struct T *[])))(const[]);
int main()
{ return 0; }
【唠叨】 2015/7/3 15:55:57
这个代码应该不全吧
或者说是不对的
【吐槽】【大牛】2015/7/3 20:33:56
？哪里不对了？   

【吐槽】【大牛】2015/7/3 20:35:21
就是把一个指向一个元素数组指针的类型定义成v而已……
【唠叨】2015/7/3 20:37:00
还是没看懂
【唠叨】 2015/7/3 20:39:37
为什么学了这么久的c，也看书了，这点破指针还是玩不转。。。    
【吐槽】【大牛】2015/7/3 20:40:35
……这个技能很简单的啊，多练就好   

【吐槽】【大牛】 2015/7/3 20:40:58
是啊
【唠叨】 2015/7/3 20:41:11
主要平时看都看不懂，怎么写呀
他这段代码就看不懂

【吐槽】【大牛】 2015/7/3 20:41:41
这代码写的很复杂，我在朋友家，回去了教你们怎么看以及怎么整理成人看的懂的格式
【唠叨】 2015/7/3 20:41:54
哦哦
好

【吐槽】【大牛】2015/7/4 1:45:54
typedef struct T{ union { struct T* (*v)(const *[]);
const * const r; };}const*(*(*(*(*v)[1])[1])(struct
{ const c;}*(*)(struct T *[])))(const[]);

// 太复杂了，怎么办？首先，我们找到第一个词，是struct，回忆struct的语
// 法：struct name { ... }，先把这个定义出来：
typedef struct T {
    union {
        struct T* (*v)(const *[]);
        const * const r;
    };
} Type1;

// 换进去：
typedef Type1 const*(*(*(*(*v)[1])[1])(struct
{ const c;}*(*)(struct T *[])))(const[]);

//然后，下一个括号是(),我们把括号里面的忽略掉，看看外面是啥？
typedef Type1 const*(...)(const[]);

// 是个函数嘛，定义一下：
typedef Type1 const* Type2(const[]);

// 换进去：
typedef Type2* (*(*(*v)[1])[1])(struct { const c;}*(*)(struct T *[]));

// 同样的办法：
typedef Type2* (Type3)(struct { const c;}*(*)(struct T *[]));
typedef Type3* (*(*v)[1])[1];

typedef Type3* Type4[1];
typedef Type4* ((*v)[1]);

typedef Type4* Type5[1];
typedef Type5* v;

// 整理一下，使用同样的方法，把任何复杂的部分提出来：
typedef struct T* Type1_Func(const *[]);
typedef struct T {
    union {
        Type1_Func* v;
        const * const r;
    };
} Type1;
typedef Type1 const* Type2(const[]);
typedef struct { const c; } Type3_Arg_Ret;
typedef struct T *Type3_Arg_Arg;
typedef Type3_Arg_Ret* Type3_Arg(Type3_Arg_Arg*);
typedef Type2* (Type3)(Type3_Arg*);
typedef Type3* Type4[1];
typedef Type4* Type5[1];
typedef Type5* v;

然后从上往下看：
1. v是一个类型（typedef）
2. 这个类型是一个指针，指向另外一个类型Type5
3. Type5是一个数组，只有一个元素，类型是指向Type4的指针。
4. Type4是一个数组，只有一个元素，类型是指向Type3的指针。
5. Type3是一个函数，这个函数返回指向Type2的指针
    - 它的参数是一个指向Type3_Arg类型的指针。
6. Type3_Arg是一个函数
    - 这个函数返回指向Type3_Arg_Ret的指针
    - 接受一个指向Type3_Arg_Arg的类型的指针。
7. Type3_Arg_Ret是一个结构体
    - 结构体里只有一个不能改变的int成员c（没有写类型的默认是int）。
8. Type3_Arg_Arg是一个指针
    - 指向结构体T（结构体T到底是什么我们还不知道，所以叫不完整类型）。
9. Type2是一个函数
    - 这个函数返回指向不能改变的Type1类型的指针
    - 接受一个不能改变的int类型的指针（指向数组，但是不强制）作为参数。
10. Type1类型是一个结构体
    - 这个结构体又叫struct T（现在struct T不是不完整类型了哦！）
    - struct T结构体只有一个匿名联合作为成员（这是不符合标准的！但是很多编译期都支持）
        - 这个匿名联合有两个成员
            - 它可以是指向Type1_Func的指针类型的v
                - Type1_Func类型是一个函数
                    - 它返回指向结构体T的指针
                    - 接受一个指向数组（不强制）的指针作为参数
                        - 这个数组的每个元素是一个指向不能改变的int类型的变量的指针。
            - 也可以是不能改变的，指向不能改变的int类型的指针r

int main()
{ return 0; }

【吐槽】【大牛】 2015/7/4 1:49:24
1. 是从下往上看
2. 这个明显不是实际例子，就是生造出来体现C的声明的复杂性的
3. 但是，这也体现了C的声明的优越性：一个很短的式子可以表达很丰富的概念
4. 然而，将这些概念用有意义的方式去分离开，才是合理的做法
5. 最后要指出的是，这是一个不符合标准的C89的声明，具体体现在：
5.1 省略int的用法在C99被废除了
5.2 任何一个C语言标准都不允许匿名联合的出现，这是一个编译器扩展，虽然VC和gcc都支持这个扩展。
我说完了