你看得懂Hello world吗？

年，兮

代码如下：
#include<stdio.h>
char *a(){return "H";}
char *a1(){return "e";}
char *a2(){return "l";}
char *a3(){return "l";}
char *a4(){return "o";}
char *a5(){return " ";}
char *a6(){return "W";}
char *a7(){return "o";}
char *a8(){return "r";}
char *a9(){return "l";}
char *a10(){return "d";}
char *a11(){return "!";}
int main()
{        int i;
        char *(*m[3][4])()={
                                                {a,a1,a2,a3},
                                                {a4,a5,a6,a7},
                                                {a8,a9,a10,a11}
                                                                                };
        char*(**p)();
        p=&m;//这里用p=m;为啥是一样的结果？
        for(i=0;i<12;i++)
        {
                printf("%s",(*(p+i))());
        }
        printf("\n");
        return 0;
}//解释一下这个程序是怎么实现的？

歌者文明清理员

这段程序使用了函数指针和二维数组来实现输出字符串 "Hello World!"。下面对代码进行逐行解释：

```c

1. #include<stdio.h>

复制代码

头文件包含标准输入输出库。

1. char *a(){return "H";}
   
2. char *a1(){return "e";}
   
3. char *a2(){return "l";}
   
4. char *a3(){return "l";}
   
5. char *a4(){return "o";}
   
6. char *a5(){return " ";}
   
7. char *a6(){return "W";}
   
8. char *a7(){return "o";}
   
9. char *a8(){return "r";}
   
10. char *a9(){return "l";}
    
11. char *a10(){return "d";}
    
12. char *a11(){return "!";}
    

复制代码

定义了12个返回类型为 char* 的函数，每个函数返回的是一个字符。

1. 
   
2. int main()
   
3. {
   
4.     int i;
   
5.     char *(*m[3][4])()={
   
6.                           {a,a1,a2,a3},
   
7.                           {a4,a5,a6,a7},
   
8.                           {a8,a9,a10,a11}
   
9.                         };
   
10.     char*(**p)();
    
11.     p=&m;//这里用p=m;为啥是一样的结果？
    
12.     for(i=0;i<12;i++)
    
13.     {
    
14.         printf("%s",(*(p+i))());
    
15.     }
    
16.     printf("\n");
    
17.     return 0;
    
18. }
    

复制代码

```
main 函数中定义了一个二维函数指针数组 m，其中每个元素都是一个指向一个返回类型为 char* 的函数的指针。接着定义了一个指向函数指针的指针 p，并将其指向数组 m。然后通过循环执行每个函数，并将函数返回的字符打印出来，最终输出 "Hello World!"。

至于为什么 `p=&m;` 和 `p=m;` 的结果是一样的，这是因为数组名本身就是一个指向数组首元素的指针，所以它和 `&m[0][0]` 是等价的。

isdkz

1、程序定义了12个函数（a, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11），分别返回 "Hello World!" 字符串中的每个字符。

2、在main函数中，程序创建了一个3x4的二维数组m，它包含指向这些函数的指针。数组的结构如下：

1. m[0] - {a,  a1,  a2,  a3}
   
2. m[1] - {a4, a5,  a6,  a7}
   
3. m[2] - {a8, a9, a10, a11}

复制代码

3、定义一个指针（char *(**p)()），它指向这个二维数组的指针。

4、为p赋值（p=&m;），使其指向m。在这个例子中，p=&m;和p=m;可以得到相同的结果，因为m是一个指向指针数组的指针，&m也是一个指向指针数组的指针。

5、程序使用一个for循环来遍历这个二维数组中的所有函数指针，并通过解引用（dereferencing）这些函数指针来调用它们，将返回的字符依次打印出来。最后，循环结束后打印一个换行符。

代码执行后的输出是 "Hello World!"。

年，兮

还没看到比较准确的答案

jhq999

年，兮 发表于 2023-4-5 15:25
还没看到比较准确的答案

1. 0x401488        push   %ebp
   
2. 0x401489        mov    %esp,%ebp
   
3. 0x40148b        and    $0xfffffff0,%esp
   
4. 0x40148e        sub    $0x50,%esp
   
5. 0x401491        call   0x401b60 <__main>
   
6. 0x401496        movl   $0x401410,0x18(%esp)
   
7. 0x40149e        movl   $0x40141a,0x1c(%esp)
   
8. 0x4014a6        movl   $0x401424,0x20(%esp)
   
9. 0x4014ae        movl   $0x40142e,0x24(%esp)
   
10. 0x4014b6        movl   $0x401438,0x28(%esp)
    
11. 0x4014be        movl   $0x401442,0x2c(%esp)
    
12. 0x4014c6        movl   $0x40144c,0x30(%esp)
    
13. 0x4014ce        movl   $0x401456,0x34(%esp)
    
14. 0x4014d6        movl   $0x401460,0x38(%esp)
    
15. 0x4014de        movl   $0x40146a,0x3c(%esp)
    
16. 0x4014e6        movl   $0x401474,0x40(%esp)
    
17. 0x4014ee        movl   $0x40147e,0x44(%esp)
    
18. 0x4014f6        lea    0x18(%esp),%eax
    
19. 0x4014fa        mov    %eax,0x48(%esp)
    
20. 0x4014fe        movl   $0x0,0x4c(%esp)
    
21. 0x401506        jmp    0x401532 <main+170>
    
22. 0x401508        mov    0x4c(%esp),%eax
    
23. 0x40150c        lea    0x0(,%eax,4),%edx
    
24. 0x401513        mov    0x48(%esp),%eax
    
25. 0x401517        add    %edx,%eax
    
26. 0x401519        mov    (%eax),%eax
    
27. 0x40151b        call   *%eax
    
28. 0x40151d        mov    %eax,0x4(%esp)
    
29. 0x401521        movl   $0x406056,(%esp)
    
30. 0x401528        call   0x403fbc <printf>
    
31. 0x40152d        addl   $0x1,0x4c(%esp)
    
32. 0x401532        cmpl   $0xb,0x4c(%esp)
    
33. 0x401537        jle    0x401508 <main+128>
    
34. 0x401539        movl   $0xa,(%esp)
    
35. 0x401540        call   0x403fb4 <putchar>
    
36. 0x401545        mov    $0x0,%eax
    
37. 0x40154a        leave
    
38. 0x40154b        ret
    

复制代码

年，兮

jhq999 发表于 2023-4-5 15:50

你是魔鬼吧

jhq999

年，兮 发表于 2023-4-5 18:07
你是魔鬼吧

其实就是函数指针的3X4数组，然后挨个调用这些函数
调用函数本来就是压栈跳转到函数所在的内存地址

年，兮

jhq999 发表于 2023-4-5 18:18
其实就是函数指针的3X4数组，然后挨个调用这些函数
调用函数本来就是压栈跳转到函数所在的内 ...

你是懂底层代码的