C语言对闭包运算的支持

tony_ayuan

回复 27# davelv

ok，函数的存储位置我猜错了。

我还是坚持这不是闭包，更不是lamda。

nested_func的参数传递与普通的（顶层翻译单元）函数是一样的。

与普通函数最大的不同就是nested_func具有访问外围函数局部变量的能力，这些局部变量存储在调用栈上。  

另外一点不同是编译后的函数名。

第1点是不能在外围函数之外直接调用nested_func的原因。
第2点是防止直接调用nested_func的机制。

下面的例子，函数a,b,e,f说明参数传递方式。函数main，q说明访问外围函数局部变量的方式。

1. 
   
2. int a(void)      
   
3. {
   
4.   return 1;
   
5. }
   
6. 
   
7. int e(int x)
   
8. {
   
9.   return x++;
   
10. }
    
11. 
    
12. int main(void)
    
13. {
    
14.   int foo1 = 1;
    
15.   int foo2 = 2;
    
16.   int foo3 = 3;
    
17. 
    
18.   int b(void)
    
19.   {
    
20.     return 1;
    
21.   }
    
22. 
    
23.   int f(int x)
    
24.   {
    
25.     return x++;
    
26.   }
    
27. 
    
28.   int q(void)
    
29.   {
    
30.     foo1++;
    
31.     foo3++;
    
32.     return 0;
    
33.   }
    
34. 
    
35.   foo2++;
    
36. 
    
37.   a();
    
38.   b();
    
39.   e(1);
    
40.   f(1);
    
41.   q();
    
42. 
    
43.   return 0;
    
44. }
    

复制代码

1. 
   
2. 0000000000400494 <a>:
   
3.   400494:       55                      push   %rbp
   
4.   400495:       48 89 e5                mov    %rsp,%rbp
   
5.   400498:       b8 01 00 00 00          mov    $0x1,%eax
   
6.   40049d:       c9                      leaveq
   
7.   40049e:       c3                      retq   
   
8. 
   
9. 000000000040049f <e>:
   
10.   40049f:       55                      push   %rbp
    
11.   4004a0:       48 89 e5                mov    %rsp,%rbp
    
12.   4004a3:       89 7d fc                mov    %edi,-0x4(%rbp)
    
13.   4004a6:       8b 45 fc                mov    -0x4(%rbp),%eax
    
14.   4004a9:       83 45 fc 01             addl   $0x1,-0x4(%rbp)
    
15.   4004ad:       c9                      leaveq
    
16.   4004ae:       c3                      retq   
    
17. 
    
18. 00000000004004af <b.1602>:
    
19.   4004af:       55                      push   %rbp
    
20.   4004b0:       48 89 e5                mov    %rsp,%rbp
    
21.   4004b3:       b8 01 00 00 00          mov    $0x1,%eax
    
22.   4004b8:       c9                      leaveq
    
23.   4004b9:       c3                      retq   
    
24. 
    
25. 00000000004004ba <main>:
    
26.   4004ba:       55                      push   %rbp
    
27.   4004bb:       48 89 e5                mov    %rsp,%rbp
    
28.   4004be:       48 83 ec 10             sub    $0x10,%rsp
    
29.   4004c2:       c7 45 f4 01 00 00 00    movl   $0x1,-0xc(%rbp)
    
30.   4004c9:       c7 45 fc 02 00 00 00    movl   $0x2,-0x4(%rbp)
    
31.   4004d0:       c7 45 f0 03 00 00 00    movl   $0x3,-0x10(%rbp)
    
32.   4004d7:       83 45 fc 01             addl   $0x1,-0x4(%rbp)
    
33.   4004db:       e8 b4 ff ff ff          callq  400494 <a>
    
34.   4004e0:       e8 ca ff ff ff          callq  4004af <b.1602>
    
35.   4004e5:       bf 01 00 00 00          mov    $0x1,%edi
    
36.   4004ea:       e8 b0 ff ff ff          callq  40049f <e>
    
37.   4004ef:       bf 01 00 00 00          mov    $0x1,%edi
    
38.   4004f4:       e8 13 00 00 00          callq  40050c <f.1605>
    
39.   4004f9:       48 8d 45 f0             lea    -0x10(%rbp),%rax
    
40.   4004fd:       49 89 c2                mov    %rax,%r10
    
41.   400500:       e8 17 00 00 00          callq  40051c <q.1608>
    
42.   400505:       b8 00 00 00 00          mov    $0x0,%eax
    
43.   40050a:       c9                      leaveq
    
44.   40050b:       c3                      retq   
    
45. 
    
46. 000000000040050c <f.1605>:
    
47.   40050c:       55                      push   %rbp
    
48.   40050d:       48 89 e5                mov    %rsp,%rbp
    
49.   400510:       89 7d fc                mov    %edi,-0x4(%rbp)
    
50.   400513:       8b 45 fc                mov    -0x4(%rbp),%eax
    
51.   400516:       83 45 fc 01             addl   $0x1,-0x4(%rbp)
    
52.   40051a:       c9                      leaveq
    
53.   40051b:       c3                      retq   
    
54. 
    
55. 000000000040051c <q.1608>:
    
56.   40051c:       55                      push   %rbp
    
57.   40051d:       48 89 e5                mov    %rsp,%rbp
    
58.   400520:       4c 89 d0                mov    %r10,%rax
    
59.   400523:       8b 50 04                mov    0x4(%rax),%edx
    
60.   400526:       83 c2 01                add    $0x1,%edx
    
61.   400529:       89 50 04                mov    %edx,0x4(%rax)
    
62.   40052c:       8b 10                   mov    (%rax),%edx
    
63.   40052e:       83 c2 01                add    $0x1,%edx
    
64.   400531:       89 10                   mov    %edx,(%rax)
    
65.   400533:       b8 00 00 00 00          mov    $0x0,%eax
    
66.   400538:       c9                      leaveq
    
67.   400539:       c3                      retq   
    
68.   40053a:       90                      nop
    
69.   40053b:       90                      nop
    
70.   40053c:       90                      nop
    
71.   40053d:       90                      nop
    
72.   40053e:       90                      nop
    
73.   40053f:       90                      nop
    

复制代码

davelv

回复 33# tony_ayuan
对语言的使用者来说，语言特性如何实现的很重要么？
或者像这种，C语言没有在语法上支持类，就不能用C写出面向对象的程序？

OwnWaterloo

回复  davelv

nested_func的参数传递与普通的（顶层翻译单元）函数是一样的。
tony_ayuan 发表于 2011-12-02 13:39

在lz一开始的例子里， 传递机制不一样。
有个局部的 i 是通过一个隐藏的 ecx 传入其地址的。

OwnWaterloo

回复 30# fallening

回复 26# 幻の上帝


真的歪了， 各种意义上……
我觉得这只能算匿名函数， 没有包进非局部的什么东西

KanonInD

回复  KanonInD

就是说受限于upvalue（内嵌函数使用的外部函数局域变量）的作用域。

你这个例子没什 ...
davelv 发表于 2011-12-02 12:56

    所以说，Nested Function就算是闭包，也是残废的闭包。

fallening

回复 36# OwnWaterloo
我觉得是创建了一个匿名的类型并为之具现了一个实例。

取决于各自的理解吧，结合下边这个更明显的例子

1.     auto p = new auto([]{});

复制代码

说是一个类型也不为过

tony_ayuan

回复 34# davelv


能写出来。更像是用C实现了一种新语言

KanonInD

闭包看上去至少要像这样：

1. 
   
2. f := [:x | [:y :z | (x+y)*z.]].
   
3. g := f value: 100.
   
4. h := f value: 5.
   
5. (g value: 200 value: 6) printNl.
   
6. (h value: 10 value: 5) printNl.
   

复制代码

davelv

回复 40# KanonInD

残废也罢，单线程下就这么凑合着用吧。看起来不怎么顺眼呢

1.         int (*f(int x))(int y,int z)
   
2.         {   
   
3.                 int n(int y, int z)
   
4.                 {   
   
5.                         return x+y+z;
   
6.                 } ;
   
7.                 return n;
   
8.         }   
   
9.         #define g f(2)
   
10.         #define h f(3)
    
11.         printf("%d,%d",g(2,2),h(2,2));

复制代码

davelv

回复 39# tony_ayuan

如果什么东西都仅限于语法，语言的范围也太狭窄了。
话题跑偏了。