casyup.me@outlook.com

0%

other/firstClassValue

Posted on

第一级值

长久以来一直不太明白之前在 lua 一本书中提到的 “第一类值”

直到今天在一本书上看到类似的解释:

一般而言, 程序设计语言总会对计算元素的可能使用方式强加上某些限制  
带有最少限制的元素具有"第一级"的状态, 第一级元素的某些特权包括:
* 可以用变量命名
* 可以提供给过程作为参数
* 可以由过程作为结果返回
* 可以包含在数据结构中

上述说的是第一级值, 猜想应该是第一类值拥有第一级特权

第一类函数

以下摘自 wiki 对第一类函数(first-class function)的解释

In computer science, a programming language is said to have first-    class functions if it treats functions as first-class citizens. This means the language supports passing functions as arguments to other functions, returning them as the values from other functions, and assigning them to variables or storing them in data structures
在计算机科学中, 一个编程语言如果对他函数就像第一类公民(??)一样, 那么就说他有第一类函数
这意味着语言支持将函数作为参数传递给其他函数
从其他函数中将其作为值返回
将其复制给变量, 或者保存到数据结构中

高阶函数

顺便 wiki 说了一下什么是高阶函数

First-class functions are a necessity for the functional programming style, in which the use of higher-order functions is a standard practice. A simple example of a higher-ordered function is the map function, which takes, as its arguments, a function and a list, and returns the list formed by applying the function to each member of the list. For a language to support map, it must support passing a function as an argument.
第一类函数对于函数化编程是必要的
其中使用高阶函数就是一个标准的实践
一个高阶函数的简单案例就是map函数
(...能意会, 但没法翻译...)
它必须支持传递函数作为参数

lambda 是如何工作的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
int main() {                                    
    auto f = [](int x, int y) { return x + y; };
    printf("%d\n",  f(1, 2) );                                                        
    return 0;                                   
}                                               
...
_ZZ4mainENKUliiE_clEii:         
.LFB3999:                       
▹   .cfi_startproc              
▹   pushq▹  %rbp                
▹   .cfi_def_cfa_offset 16      
▹   .cfi_offset 6, -16          
▹   movq▹   %rsp, %rbp          
▹   .cfi_def_cfa_register 6     
▹   movq▹   %rdi, -8(%rbp)      // 唯一的区别在于, 多传了一个"this"
▹   movl▹   %esi, -12(%rbp)     
▹   movl▹   %edx, -16(%rbp)     
▹   movl▹   -16(%rbp), %eax     
▹   movl▹   -12(%rbp), %edx     
▹   addl▹   %edx, %eax          
▹   popq▹   %rbp                
▹   .cfi_def_cfa 7, 8           
▹   ret                         
...
▹   subq▹   $16, %rsp
▹   leaq▹   -1(%rbp), %rax	// 这个 this 指向了当前栈帧, 但是这里为什么要 -1 ?
▹   movl▹   $2, %edx
▹   movl▹   $1, %esi
▹   movq▹   %rax, %rdi            
▹   call▹   _ZZ4mainENKUliiE_clEii

在上面基础上, 让 lambda 捕获局部变量和全局变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
int gi = 11;
int main() {
    int i = 10;
    auto f = [i, gi](int x, int y) { return i + gi + x + y; };
    printf("%d\n",  f(1, 2) );
    return 0;
}
...
_ZZ4mainENKUliiE_clEii:     
.LFB3999:                   
▹   .cfi_startproc          
▹   pushq▹  %rbp            
▹   .cfi_def_cfa_offset 16  
▹   .cfi_offset 6, -16      
▹   movq▹   %rsp, %rbp      
▹   .cfi_def_cfa_register 6 
▹   movq▹   %rdi, -8(%rbp)  
▹   movl▹   %esi, -12(%rbp) 
▹   movl▹   %edx, -16(%rbp) 
▹   movq▹   -8(%rbp), %rax  
▹   movl▹   (%rax), %edx    
▹   movl▹   gi(%rip), %eax  	// @warning 即使是按值捕获, 全局变量也并未产生复制
▹   addl▹   %eax, %edx      
▹   movl▹   -12(%rbp), %eax 
▹   addl▹   %eax, %edx      
▹   movl▹   -16(%rbp), %eax 
▹   addl▹   %edx, %eax      
▹   popq▹   %rbp            
▹   .cfi_def_cfa 7, 8       
▹   ret                    
...
▹   subq▹   $16, %rsp             
▹   movl▹   $10, -4(%rbp)         
▹   movl▹   -4(%rbp), %eax        
▹   movl▹   %eax, -16(%rbp)       // 复制了一份 i
▹   leaq▹   -16(%rbp), %rax       
▹   movl▹   $2, %edx              
▹   movl▹   $1, %esi              
▹   movq▹   %rax, %rdi            
▹   call▹   _ZZ4mainENKUliiE_clEii

其中关键之处在于对待全局变量的方式, 这有可能产生错误, 事实也的确错了

1
2
3
4
5
6
printf("%d\n",  f(1, 2) );
gi = 100;
printf("%d\n",  f(1, 2) );
...
24
113 // gi 的值改变后, 输出结果也随之改变, 这不应该是按值捕获的结果

那么如果我加上 mutable 去更改这个 gi 呢?

1
2
3
4
5
6
7
8
auto f = [i, gi](int x, int y) mutable { gi = 110; return i + gi + x + y; };
printf("%d\n",  gi);      
printf("%d\n",  f(1, 2) );
printf("%d\n",  gi);
...
11
123
110	// 改变了! 这可是很重要的细节

上述结果, 编译器(gcc 4.8.5)只有一个警告

但是如果不注意这个细节, 去捕获全局变量, 可能会有很严重的错误

接下来专注一下类类型变量, 他会如何捕获 (这里的代码就有点头疼了)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
int main() {                                   
    vector<int> v {1, 2, 3, 4};                
    int i = 10;                                
    auto f = [i, gi, v](int x, int y) mutable {
        v[2] = 10; gi = 110;·                  
        return i + gi + x + y; };              
    printf("%d\n",  gi);                       
    printf("%d\n",  f(1, 2) );                 
    printf("%d\n",  v[2]);                     

    return 0;                                  
}                                           
...
main:                                                          
.LFB3998:          
▹   pushq▹  %rbp                                                                       
▹   movq▹   %rsp, %rbp                                         
▹   pushq▹  %r13                                               
▹   pushq▹  %r12                                               
▹   pushq▹  %rbx                                               
▹   subq▹   $72, %rsp                                          
▹   leaq▹   -37(%rbp), %rax                                    
▹   movq▹   %rax, %rdi                                         
▹   call▹   _ZNSaIiEC1Ev                                       
▹   movl▹   $._91, %r12d                                       
▹   movl▹   $4, %r13d           // 这里的 4 是告诉 vector, 有 4 个元素 (猜的)
▹   leaq▹   -37(%rbp), %rdi                                    
▹   movq▹   %r12, %rcx                                         
▹   movq▹   %r13, %rbx                                         
▹   movq▹   %r12, %rax                                         
▹   movq▹   %r13, %rdx                                         
▹   movq▹   %rcx, %rsi                                         
▹   leaq▹   -64(%rbp), %rax     // 按照上下文理解, 这应该就是 vector 的 this 指针   
▹   movq▹   %rdi, %rcx                                         
▹   movq▹   %rax, %rdi                                         
.LEHB0:                                                        
▹   call▹   _ZNSt6vectorIiSaIiEEC1ESt16initializer_listIiERKS0_ // 真是个丑陋的小东西 = = 
.LEHE0:                                                        
▹   leaq▹   -37(%rbp), %rax                                    
▹   movq▹   %rax, %rdi                                         
▹   call▹   _ZNSaIiED1Ev                                       
▹   movl▹   $10, -36(%rbp)                                     
▹   movl▹   -36(%rbp), %eax                                    
▹   movl▹   %eax, -96(%rbp)       // 上面的 10 是路标, 这个应该就是 lambda 的 this 指针
▹   leaq▹   -64(%rbp), %rax       
▹   leaq▹   -96(%rbp), %rdx
▹   addq▹   $8, %rdx                                           
▹   movq▹   %rax, %rsi                                         
▹   movq▹   %rdx, %rdi                                         
.LEHB1:                                                        
▹   call▹   _ZNSt6vectorIiSaIiEEC1ERKS1_      // 上面那句最长的应该是列表初始化, 而这一句                 								// 可能是拷贝或者构造? 
.LEHE1:                               
▹   movl▹   gi(%rip), %eax       
▹   movl▹   %eax, %esi
▹   movl▹   $.LC0, %edi
▹   movl▹   $0, %eax
.LEHB2:
▹   call▹   printf
▹   leaq▹   -96(%rbp), %rax
▹   movl▹   $2, %edx
▹   movl▹   $1, %esi
▹   movq▹   %rax, %rdi
▹   call▹   _ZZ4mainENUliiE_clEii
...
_ZZ4mainENUliiE_clEii:              
.LFB4000:                           
▹   .cfi_startproc                  
▹   pushq▹  %rbp                    
▹   .cfi_def_cfa_offset 16          
▹   .cfi_offset 6, -16              
▹   movq▹   %rsp, %rbp              
▹   .cfi_def_cfa_register 6         
▹   subq▹   $16, %rsp               
▹   movq▹   %rdi, -8(%rbp)        // this 指针  
▹   movl▹   %esi, -12(%rbp)         
▹   movl▹   %edx, -16(%rbp)         
▹   movq▹   -8(%rbp), %rax          
▹   addq▹   $8, %rax                
▹   movl▹   $2, %esi                
▹   movq▹   %rax, %rdi
▹   call▹   _ZNSt6vectorIiSaIiEEixEm
▹   movl▹   $10, (%rax)             // 赋值
▹   movl▹   $110, gi(%rip)
▹   movq▹   -8(%rbp), %rax
▹   movl▹   (%rax), %edx
▹   movl▹   gi(%rip), %eax
▹   addl▹   %eax, %edx
▹   movl▹   -12(%rbp), %eax
▹   addl▹   %eax, %edx
▹   movl▹   -16(%rbp), %eax
▹   addl▹   %edx, %eax
▹   leave
▹   .cfi_def_cfa 7, 8
▹   ret

值拷贝类的时候, 会将整个类拷贝一次, 并没有什么特殊的

匿名函数与其说是函数, 不如说是类 他就像一个重载了调用运算符的类一样