swift之闭包与leaq、movq

一、闭包

1.1-闭包表达式

/*
 在swift中，可以通过func定义一个函数，也可以通过闭包表达式定义一个函数
 公式：
 {
    (参数列表) -> 返回值类型 in 函数体代码
 }
*/

func sum(_ v1:Int,_ v2:Int)->Int{v1+v2}
print(sum(1, 1))

var fn = {
    (_ v1:Int, _ v2:Int)->Int in
    return v1+v2
}
print(fn(2, 2))

//匿名表达式
{
    (v1:Int,v2:Int) -> Int in
    return v1 + v2
}(3,3)

1.2-闭包表达式的简写

func test(a:Int,b:Int,fn:(Int,Int)->Int){
    print(fn(a,b))
}
//1:
test(a:1,b:2,fn:{(a:Int,b:Int)->Int in return a+b})
//2:
test(a:3,b:4,fn:{a,b in return a+b})
//3:
test(a:5,b:6,fn:{a,b in a+b})
//4:
test(a:7,b:8,fn:{$0+$1})
//5:
test(a:9,b:10,fn:+)
})
3
7
11
15
19

1.3-尾随闭包

/*如果将一个很长的闭包表达式作为函数的最后一个实参（最后一个实参重点），使用尾随闭包增强函数的可读性
  尾随闭包是一个被书写在函数调用括号外面的闭包表达式
  如果闭包表达式是函数的唯一实参，而且使用了尾随闭包语法，那就不要在函数后面写圆括号
 */
func test1(a:Int,b:Int,fn:(Int,Int)->Int){print(fn(a,b))}
test1(a:1,b:2){$0+$1}

func test2(fn:(Int,Int)->Int){print(fn(2,2))}
test2(fn:{$0+$1})
test2(){$0+$1}
test2{$0+$1}
3
4
4
4

1.4-闭包使用示例-数组排序

func cmp(a:Int,b:Int)->Bool{
    return a>b
}
var array=[3,1,2,5,2,4,6]
array.sort(by:cmp)
print(array)
[6, 5, 4, 3, 2, 2, 1]


array.sort(by:{
    (a:Int,b:Int)->Bool in
    return a<b
})
print(array) [1, 2, 2, 3, 4, 5, 6]
array.sort(by:{a,b in return a>b})
print(array) [6, 5, 4, 3, 2, 2, 1]
array.sort(by:{a,b in a<b})
print(array) [1, 2, 2, 3, 4, 5, 6]
array.sort(by:{$0>$1})
print(array) [6, 5, 4, 3, 2, 2, 1]
array.sort(by:<)
print(array) [1, 2, 2, 3, 4, 5, 6]
array.sort(){$0>$1}
print(array) [6, 5, 4, 3, 2, 2, 1]
array.sort{$0<$1}
print(array) [1, 2, 2, 3, 4, 5, 6]

1.5-忽略参数

//在函数不使用参数的情况下可以使用_忽略
func test(fn:(Int,Int)->Int){
    print(fn(1,2))
}
test {_,_ in 1}
1

1.6-自动闭包

//如果第一个数大于0返回第一个数，否则返回第二个数
func test1(_ a:Int,_ b:Int)->Int{
    return a>0 ? a:b
}
print(test1(1,2))
print(test1(-1,2))
print(test1(1,-2))
1
2
1

//改成函数类型参数，让b延迟加载
func test2(_ a:Int,_ b:()->Int)->Int?{
    return a > 0 ? a:b()
}
print(test2(-1){2})
Optional(2)

/*
1、@autoclosure会将2封装成闭包{2}
2、@autoclosure只支持（）-> T 格式的参数
3、@autoclosure并非只支持最后一个参数
4、空合并运算符??使用了@autoclosure技术
5、有@autoclosure、无@autoclosure，构成了函数重载
6、为避免与期望冲突，使用@autoclosure的地方最好注释这个值会被延迟执行
*/
func test3(_ a:Int,_ b:@autoclosure()->Int)->Int?{
    return a>0 ? a:b()
}
print(test3(-1,2))
Optional(2)

1.7-闭包和类

/*
定义
1、一个函数和它所捕获的变量、常量环境组合起来称为闭包
2、一般指定义在函数内部的函数
3、一般它捕获的是最外层函数的局部变量、常量
4、可以把闭包想象成一个类的实例对象
5、内存在堆空间
6、捕获的局部变量、常量就是类的成员、属性
7、组成闭包的函数就是类内部定义的方法
*/
typealias Fn = (Int)->Int
func getFn()->Fn{
    var num=0
    func plus(_ i:Int)->Int{
        num+=i
        return num
    }
    return plus
}
var fn1=getFn()
var fn2=getFn()
print(fn1(1))
print(fn2(2))
print(fn1(3))
print(fn2(4))
1
2
4
6

class Test{
    var num=0
    func plus(_ i:Int)->Int{
        num+=i
        return num
    }
}
var t1=Test()
var t2=Test()
print(t1.plus(1))
print(t2.plus(2))
print(t1.plus(3))
print(t2.plus(4))
1
2
4
6

二、扩展:汇编leaq和movq区别

leaq 0xd(%rip), %rax
	//rip+0xd算出来的地址给rax
movq 0xd(%rip), %rax
	//rip+0xd从这个内存地址开始8个字节的内容给rax