閉包

閉包能夠捕獲和存儲(chǔ)定義在其上下文中的任何常量和變量的引用，這也就是所謂的閉合并包裹那些常量和變量客们，因此被稱(chēng)為“閉包”，Swift 能夠?yàn)槟闾幚硭嘘P(guān)于捕獲的內(nèi)存管理的操作材诽。

閉包的三種形式

• 【全局函數(shù)是一種特殊的閉包】：全局函數(shù)是一個(gè)有名字但不會(huì)捕獲任何值的閉包

//定義一個(gè)全局函數(shù)底挫，只是當(dāng)前的全局函數(shù)并不捕獲值
func test() {
    print("test")
}

• 【內(nèi)嵌函數(shù)是一個(gè)有名字且能從其上層函數(shù)捕獲值的閉包】：下面的函數(shù)是一個(gè)閉包，函數(shù)中的incrementer是一個(gè)內(nèi)嵌函數(shù)脸侥，可以從makeIncrementer中捕獲變量runningTotal

func makeIncrementer() -> () -> Int{
    var runningTotal = 10
    //內(nèi)嵌函數(shù)凄敢，也是一個(gè)閉包
    func incrementer() -> Int{
        runningTotal += 1
        return runningTotal
    }
    return incrementer
}

• 【閉包表達(dá)式】：是一個(gè)輕量級(jí)語(yǔ)法所寫(xiě)的可以捕獲其上下文中常量或變量值的沒(méi)有名字的閉包

下面是一個(gè)閉包表達(dá)式，即一個(gè)匿名函數(shù)湿痢，而且是從上下文中捕獲變量和常量

//閉包表達(dá)式語(yǔ)法有如下的一般形式：
{ (parameters) -> (return type) in
    statements
}

使用閉包的好處

• 1涝缝、利用上下文推斷形式參數(shù)和返回值的類(lèi)型；
• 2譬重、單表達(dá)式的閉包可以隱式返回拒逮，即省略return關(guān)鍵字；
• 3臀规、簡(jiǎn)寫(xiě)實(shí)際參數(shù)名滩援，例如$0表示第一個(gè)參數(shù)；
• 4塔嬉、尾隨閉包語(yǔ)法玩徊；

閉包表達(dá)式

OC與Swift的對(duì)比

• OC中的Block其實(shí)是一個(gè)匿名函數(shù)，需要具備以下特點(diǎn)：

  • 1谨究、作用域 {}
  • 2恩袱、參數(shù)和返回值
  • 3、函數(shù)體（in）之后的代碼

• Swift中的閉包胶哲，可以當(dāng)做變量畔塔，也可以當(dāng)做參數(shù)傳遞

var clourse: (Int)->(Int) = { (age: Int) in
    return age
}

閉包表達(dá)式的使用方式

• 【可選類(lèi)型的閉包表達(dá)式】1、將閉包表達(dá)式聲明成一個(gè)可選類(lèi)型

//聲明一個(gè)可選類(lèi)型的閉包
<!--錯(cuò)誤寫(xiě)法-->
var clourse: (Int) -> Int?
clourse = nil

<!--正確寫(xiě)法-->
var clourse: ((Int) -> Int)?
clourse = nil

• 【閉包常量】2、通過(guò)let將閉包聲明成一個(gè)常量（即一旦賦值之后就不能更改）

//2澈吨、通過(guò)let將閉包聲明為一個(gè)常量把敢，即一旦賦值后就不能改變了
let clourse: (Int) -> Int
clourse = {(age: Int) in
    return age
}
//報(bào)錯(cuò)：Immutable value 'clourse' may only be initialized once
clourse = {(age: Int) in
    return age
}

image

• 【閉包參數(shù)】3、將閉包作為 函數(shù)的參數(shù)

//3谅辣、將閉包作為函數(shù)的參數(shù)
func test(param: () -> Int){
    print(param())
}
var age = 10
test { () -> Int in
    age += 1
    return age
}

尾隨閉包

當(dāng)閉包作為函數(shù)的最后一個(gè)參數(shù)修赞，如果當(dāng)前的閉包表達(dá)式很長(zhǎng)，我們可以通過(guò)尾隨閉包的書(shū)寫(xiě)方法來(lái)提高代碼的可讀性

//閉包表達(dá)式作為函數(shù)的最后一個(gè)參數(shù)
func test(_ a: Int, _ b: Int, _ c: Int, by: (_ item1: Int, _ item2: Int, _ item3: Int) -> Bool) -> Bool{
    return by(a, b, c)
    
}
//常規(guī)寫(xiě)法
test(10, 20, 30, by: {(_ item1: Int, _ item2: Int, _ item3: Int) -> Bool in
        return (item1 + item2 < item3)
})
//尾隨閉包寫(xiě)法
test(10, 20, 30) { (item1, item2, item3) -> Bool in
    return (item1 + item2 < item3)
}

• 我們平常使用的array.sorted其實(shí)就是一個(gè)尾隨閉包桑阶，且這個(gè)函數(shù)就只有一個(gè)參數(shù)榔组，如下所示

//array.sorted就是一個(gè)尾隨閉包
var array = [1, 2, 3]
//1、完整寫(xiě)法
array.sorted { (item1: Int, item2: Int) -> Bool in return item1 < item2}
//2联逻、省略參數(shù)類(lèi)型：通過(guò)array中的參數(shù)推斷類(lèi)型
array.sorted { (item1, item2) -> Bool in return item1 < item2}
//3搓扯、省略參數(shù)類(lèi)型 + 返回值類(lèi)型：通過(guò)return推斷返回值類(lèi)型
array.sorted { (item1, item2) in return item1 < item2}
//4、省略參數(shù)類(lèi)型 + 返回值類(lèi)型 + return關(guān)鍵字：?jiǎn)伪磉_(dá)式可以隱式返回表達(dá)包归，即省略return關(guān)鍵字
array.sorted { (item1, item2) in item1 < item2}
//5锨推、參數(shù)名稱(chēng)簡(jiǎn)寫(xiě)
array.sorted {return $0 < $1}
//6、參數(shù)名稱(chēng)簡(jiǎn)寫(xiě) + 省略return關(guān)鍵字
array.sorted {$0 < $1}
//7公壤、最簡(jiǎn)：直接傳比較符號(hào)
array.sorted (by: <)

捕獲原理

捕獲一個(gè)值

下面代碼的打印結(jié)果是什么换可？

func makeIncrementer() -> () -> Int {
    var runningTotal = 10
    //內(nèi)嵌函數(shù)，也是一個(gè)閉包
    func incrementer() -> Int {
        runningTotal += 1
        return runningTotal
    }
    return incrementer
}
let makeInc = makeIncrementer()
print(makeInc())
print(makeInc())
print(makeInc())

<!--打印結(jié)果-->
11
12
13

打印結(jié)果如下厦幅，從結(jié)果中可以看出沾鳄，每次的結(jié)果都是在上次函數(shù)執(zhí)行的基礎(chǔ)上累加的，但是我們所知的runningTotal是一個(gè)臨時(shí)變量确憨，按理說(shuō)每次進(jìn)入函數(shù)都是10译荞，這里為什么會(huì)每次累加呢？ 主要原因：內(nèi)嵌函數(shù)捕獲了runningTotal休弃，不再是單純的一個(gè)變量了

• 如果是下面這種方式調(diào)用呢吞歼？

print(makeIncrementer()())
print(makeIncrementer()())
print(makeIncrementer()())

<!--打印結(jié)果-->
11
11
11

為什么這種方式每次打印的結(jié)果就是同一個(gè)呢？

1塔猾、SIL分析

將上述代碼通過(guò)SIL分析：

• 1篙骡、通過(guò)alloc_box在堆上申請(qǐng)了一塊內(nèi)存空間，并將變量存儲(chǔ)到堆上
• 2丈甸、通過(guò)project_box從堆上取出變量

• 3糯俗、將取出的變量交給閉包進(jìn)行調(diào)用

  
  
  image

結(jié)論：捕獲值的本質(zhì)是 將變量存儲(chǔ)到堆上

2、斷點(diǎn)驗(yàn)證

• 也可以通過(guò)斷點(diǎn)來(lái)驗(yàn)證睦擂，在makeIncrementer方法內(nèi)部調(diào)用了swift_allocObject方法

image

總結(jié)

• 一個(gè)閉包能夠從上下文捕獲已經(jīng)定義的常量和變量得湘，即使這些定義的常量和變量的原作用域不存在，閉包仍然能夠在其函數(shù)體內(nèi)引用和修改這些值
• 當(dāng)每次修改捕獲值時(shí)祈匙，修改的是堆區(qū)中的value值
• 當(dāng)每次重新執(zhí)行當(dāng)前函數(shù)時(shí)忽刽，都會(huì)重新創(chuàng)建內(nèi)存空間

所以上面的案例中我們知道：

• makeInc是用于存儲(chǔ)makeIncrementer函數(shù)調(diào)用的全局變量，所以每次都需要依賴(lài)上一次的結(jié)果
• 而直接調(diào)用函數(shù)時(shí)夺欲，相當(dāng)于每次都新建一個(gè)堆內(nèi)存跪帝，所以每次的結(jié)果都是不關(guān)聯(lián)的，即每次結(jié)果都是一致的

閉包是引用類(lèi)型

這里還要一個(gè)疑問(wèn)些阅，makeInc存儲(chǔ)的到底是什么伞剑？個(gè)人猜測(cè)存儲(chǔ)的是runningTotal的堆區(qū)地址，下面我們通過(guò)分析來(lái)驗(yàn)證是否如此

但是此時(shí)我們發(fā)現(xiàn)市埋，通過(guò)SIL并沒(méi)有辦法分析出什么黎泣，那么可以將SIL降一級(jí)，通過(guò)IR代碼來(lái)觀察數(shù)據(jù)的構(gòu)成

在分析之前缤谎，首先來(lái)了解下IR的基本語(yǔ)法

IR基本語(yǔ)法

• 通過(guò)以下命令將代碼轉(zhuǎn)換為IR文件

swiftc -emit-ir 文件名 > ./main.ll && code main.ll

例如：
- cd 文件所在路徑
- swiftc -emit-ir main.swift > ./main.ll && open main.ll

• 數(shù)組

/*
- elementnumber 數(shù)組中存放數(shù)據(jù)的數(shù)量
- elementtype 數(shù)組中存放數(shù)據(jù)的類(lèi)型
*/
[<elementnumber> x <elementtype>]

<!--舉例-->
/*
24個(gè)i8都是0
- iN：表示多少位的整型抒倚，即8位的整型 - 1字節(jié)
*/
alloca [24 x i8], align 8

• 結(jié)構(gòu)體

/*
- T：結(jié)構(gòu)體名稱(chēng)
- <type list> ：列表，即結(jié)構(gòu)體的成員列表
*/
//和C語(yǔ)言的結(jié)構(gòu)體類(lèi)似
%T = type {<type list>}


<!--舉例-->
/*
- swift.refcounted：結(jié)構(gòu)體名稱(chēng)
- %swift.type*：swift.type指針類(lèi)型
- i64：64位整型 - 8字節(jié)
*/
%swift.refcounted = type { %swift.type*, i64}

• 指針類(lèi)型

<type> *

<!--舉例-->
//64位的整型 - 8字節(jié)
i64*

• getelementptr指令

在LLVM中獲取數(shù)組和結(jié)構(gòu)體的成員時(shí)通過(guò)getelementptr坷澡，語(yǔ)法規(guī)則如下：

<result> = getelementptr <ty>, <ty>* <ptrval>{, [inrange] <ty> <id x>}*

<result> = getelementptr inbounds <ty>, <ty>* <ptrval>{, [inrange] <ty> <idx>}*

<!--舉例-->
struct munger_struct{
    int f1;
    int f2;
};
void munge(struct munger_struct *P){
    P[0].f1 = P[1].f1 + P[2].f2;
}

//使用
struct munger_struct* array[3];

int main(int argc, const char * argv[]) {
    
    munge(array);
    
    return 0;
}

通過(guò)下面的命令將c/c++編譯成IR

clang -S -emit-llvm 文件名 > ./main.ll && code main.ll

<!--舉例-->
clang -S -emit-llvm ${SRCROOT}/HTClourseTest/main.c > ./main.ll && "/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code" main.ll

image

結(jié)合圖來(lái)理解

int main(int argc, const char * argv[]) { 
    int array[4] = {1, 2, 3, 4}; 
    int a = array[0];
    return 0;
}
其中int a = array[0];這句對(duì)應(yīng)的LLVM代碼應(yīng)該是這樣的：
/*
- [4 x i32]* array：數(shù)組首地址
- 第一個(gè)0：相對(duì)于數(shù)組自身的偏移托呕，即偏移0字節(jié) 0 * 4字節(jié)
- 第二個(gè)0：相對(duì)于數(shù)組元素的偏移，即結(jié)構(gòu)體第一個(gè)成員變量 0 * 4字節(jié)
*/
a = getelementptr inbounds [4 x i32], [4 x i32]* array, i64 0, i64 0

• 可以看到其中的第一個(gè)0频敛，使用基本類(lèi)型[4 x i32]项郊，因此返回的指針前進(jìn)0 * 16字節(jié)，即當(dāng)前數(shù)組首地址
• 第二個(gè)index斟赚，使用基本類(lèi)型 i32着降，返回的指針前進(jìn)0字節(jié)，即當(dāng)前數(shù)組的第一個(gè)元素拗军，返回的指針類(lèi)型是 i32*

image

總結(jié)

• 第一個(gè)索引不會(huì)改變返回的指針的類(lèi)型任洞，即ptrval前面的*對(duì)應(yīng)什么類(lèi)型，返回的就是什么類(lèi)型
• 第一個(gè)索引的偏移量是由第一個(gè)索引的值和第一個(gè)ty指定的基本類(lèi)型共同確定的
• 后面的索引是在數(shù)組或者結(jié)構(gòu)體內(nèi)進(jìn)行索引
• 每增加一個(gè)索引发侵，就會(huì)使得該索引使用的基本類(lèi)型和返回的指針類(lèi)型去掉一層（例如 [4 x i32] 去掉一層是 i32）

IR分析

分析IR代碼

• 查看makeIncrementer方法
  • 1侈咕、首先通過(guò)swift_allocObject創(chuàng)建swift.refcounted結(jié)構(gòu)體
  • 2、然后將swift.refcounted轉(zhuǎn)換為<{ %swift.refcounted, [8 x i8] }>*結(jié)構(gòu)體（即Box）
  • 3器紧、取出結(jié)構(gòu)體中index等于1的成員變量耀销，存儲(chǔ)到[8 x i8]*連續(xù)的內(nèi)存空間中
  • 4、將內(nèi)嵌函數(shù)的地址存儲(chǔ)到i8即void地址中
  • 5铲汪、最后返回一個(gè)結(jié)構(gòu)體

image

其結(jié)構(gòu)體定義如下

image

仿寫(xiě)

通過(guò)上述的分析熊尉，仿寫(xiě)其內(nèi)部的結(jié)構(gòu)體，然后構(gòu)造一個(gè)函數(shù)的結(jié)構(gòu)體掌腰，將makeInc的地址綁定到結(jié)構(gòu)體中

struct HeapObject {
    var type: UnsafeRawPointer
    var refCount1: UInt32
    var refCount2: UInt32
}

//函數(shù)返回值結(jié)構(gòu)體
//BoxType 是一個(gè)泛型狰住，最終是由傳入的Box決定的
struct FunctionData<BoxType>{
    //內(nèi)嵌函數(shù)地址
    var ptr: UnsafeRawPointer
    var captureValue: UnsafePointer<BoxType>
}

//捕獲值的結(jié)構(gòu)體
struct Box<T> {
    var refCounted: HeapObject
    var value: T
}

//封裝閉包的結(jié)構(gòu)體，目的是為了使返回值不受影響
struct VoidIntFun {
    var f: () ->Int
}

//下面代碼的打印結(jié)果是什么齿梁？
func makeIncrementer() -> () -> Int{
    var runningTotal = 10
    //內(nèi)嵌函數(shù)催植，也是一個(gè)閉包
    func incrementer() -> Int{
        runningTotal += 1
        return runningTotal
    }
    return incrementer
}
let makeInc = VoidIntFun(f: makeIncrementer())

let ptr = UnsafeMutablePointer<VoidIntFun>.allocate(capacity: 1)
//初始化的內(nèi)存空間
ptr.initialize(to: makeInc)
//將ptr重新綁定內(nèi)存
let ctx = ptr.withMemoryRebound(to: FunctionData<Box<Int>>.self, capacity: 1) {
     $0.pointee
}
print(ctx.ptr)
print(ctx.captureValue.pointee)

<!--打印結(jié)果-->
0x00000001000018f0
Box<Int>(refCounted: HTClourseTest.HeapObject(type: 0x0000000100004038, refCount1: 2, refCount2: 2), value: 10)

• 終端命令查找00000001000018f0（其中0x00000001000018f0 是內(nèi)嵌函數(shù)的地址）

nm -p HTClourseTest | grep 00000001000018f0

其中t _$s13HTClourseTest15makeIncrementerSiycyF11incrementerL_SiyFTA是內(nèi)嵌函數(shù)的地址對(duì)應(yīng)的符號(hào)

image

結(jié)論：所以當(dāng)我們var makeInc2 = makeIncrementer()使用時(shí)肮蛹，相當(dāng)于給makeInc2就是FunctionData結(jié)構(gòu)體，其中關(guān)聯(lián)了內(nèi)嵌函數(shù)地址创南，以及捕獲變量的地址伦忠，所以才能在上一個(gè)的基礎(chǔ)上進(jìn)行累加

捕獲兩個(gè)變量的情況

上面的案例中，我們分析了閉包捕獲一個(gè)變量的情況稿辙，如果是將捕獲一個(gè)變量更改為捕獲兩個(gè)變量呢昆码？如下所示修改makeIncrementer函數(shù)

func makeIncrementer(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    //內(nèi)嵌函數(shù)，也是一個(gè)閉包
    func incrementer() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}

• 查看其IR代碼

image

內(nèi)部結(jié)構(gòu)仿寫(xiě)

根據(jù)捕獲一個(gè)變量的仿寫(xiě)邻储，繼續(xù)仿寫(xiě)捕獲兩個(gè)變量的情況

//2赋咽、閉包捕獲多個(gè)值的原理
struct HeapObject {
    var type: UnsafeRawPointer
    var refCount1: UInt32
    var refCount2: UInt32
}

//函數(shù)返回值結(jié)構(gòu)體
//BoxType 是一個(gè)泛型，最終是由傳入的Box決定的
struct FunctionData<BoxType>{
    var ptr: UnsafeRawPointer//內(nèi)嵌函數(shù)地址
    var captureValue: UnsafePointer<BoxType>
}

//捕獲值的結(jié)構(gòu)體
struct Box<T> {
    var refCounted: HeapObject
    var value: T
}

//封裝閉包的結(jié)構(gòu)體吨娜，目的是為了使返回值不受影響
struct VoidIntFun {
    var f: () ->Int
}

//下面代碼的打印結(jié)果是什么脓匿？
func makeIncrementer(forIncrement amount: Int) -> () -> Int{
    var runningTotal = 0
    //內(nèi)嵌函數(shù)，也是一個(gè)閉包
    func incrementer() -> Int{
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}
var makeInc = makeIncrementer(forIncrement: 10)
var f = VoidIntFun(f: makeInc)

let ptr = UnsafeMutablePointer<VoidIntFun>.allocate(capacity: 1)
//初始化的內(nèi)存空間
ptr.initialize(to: f)
//將ptr重新綁定內(nèi)存
let ctx = ptr.withMemoryRebound(to: FunctionData<Box<Int>>.self, capacity: 1) {
     $0.pointee
}
print(ctx.ptr)
print(ctx.captureValue)

<!--打印結(jié)果-->
0x00000001000058c0
0x0000000100640310

• 通過(guò)終端命令查看第一個(gè)地址是否是內(nèi)嵌函數(shù)的地址

image

• 通過(guò)cat查看 第一個(gè)地址宦赠，即內(nèi)嵌函數(shù)的地址

image

• x/8g第二個(gè)地址

image

• 繼續(xù)查看內(nèi)存情況

image

如果將runningTotal改成12呢亦镶？來(lái)驗(yàn)證是否如我們猜想的一樣。事實(shí)證明袱瓮，確實(shí)是存儲(chǔ)的runningTotal

image

所以缤骨，閉包捕獲兩個(gè)變量時(shí)，Box結(jié)構(gòu)體內(nèi)部發(fā)生了變化尺借，修改后的仿寫(xiě)代碼如下：

//2屋灌、閉包捕獲多個(gè)值的原理
struct HeapObject {
    var type: UnsafeRawPointer
    var refCount1: UInt32
    var refCount2: UInt32
}

//函數(shù)返回值結(jié)構(gòu)體
//BoxType 是一個(gè)泛型械蹋，最終是由傳入的Box決定的
struct FunctionData<BoxType>{
    var ptr: UnsafeRawPointer//內(nèi)嵌函數(shù)地址
    var captureValue: UnsafePointer<BoxType>
}

//捕獲值的結(jié)構(gòu)體
struct Box<T> {
    var refCounted: HeapObject
    //valueBox用于存儲(chǔ)Box類(lèi)型
    var valueBox: UnsafeRawPointer
    var value: T
}

//封裝閉包的結(jié)構(gòu)體，目的是為了使返回值不受影響
struct VoidIntFun {
    var f: () ->Int
}

//下面代碼的打印結(jié)果是什么？
func makeIncrementer(forIncrement amount: Int) -> () -> Int{
    var runningTotal = 12
    //內(nèi)嵌函數(shù)僧鲁，也是一個(gè)閉包
    func incrementer() -> Int{
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}

var makeInc = makeIncrementer(forIncrement: 10)
var f = VoidIntFun(f: makeInc)

let ptr = UnsafeMutablePointer<VoidIntFun>.allocate(capacity: 1)
//初始化的內(nèi)存空間
ptr.initialize(to: f)
//將ptr重新綁定內(nèi)存
let ctx = ptr.withMemoryRebound(to: FunctionData<Box<Int>>.self, capacity: 1) {
     $0.pointee
}
print(ctx.ptr)
print(ctx.captureValue.pointee)
print(ctx.captureValue.pointee.valueBox)

<!--打印結(jié)果-->
0x0000000100005860
Box<Int>(refCounted: HTClourseTest.HeapObject(type: 0x0000000100008098, refCount1: 2, refCount2: 4), valueBox: 0x0000000100481330, value: 10)
0x0000000100481330

疑問(wèn)：如果是捕獲3個(gè)變量呢颅停？

• 如下所示卷谈，是捕獲三個(gè)值的內(nèi)存情況

image

• 通過(guò)IR文件發(fā)現(xiàn)吸重，從返回值倒推

<!--返回值-->
ret { i8*, %swift.refcounted* } %15

<!--%15-->
%15 = insertvalue { i8*, %swift.refcounted* }
{ i8* bitcast (i64 (%swift.refcounted*)* @"$s4main15makeIncrementer12forIncrement7amount2SiycSi_SitF11incrementerL_SiyFTA" to i8*),
    %swift.refcounted* undef }, %swift.refcounted* %10, 1

<!--%10-->
//與捕獲兩個(gè)變量相比，區(qū)別在于 i64 32 變成了 i64 40
%10 = call noalias %swift.refcounted* @swift_allocObject(
%swift.type* getelementptr inbounds (%swift.full_boxmetadata, %swift.full_boxmetadata* @metadata.3, i32 0, i32 2),
i64 40, i64 7) #1

所以Box結(jié)構(gòu)體改為

//捕獲值的結(jié)構(gòu)體
struct Box<T> {
    var refCounted: HeapObject
    //這也是一個(gè)HeapObject
    var valueBox: UnsafeRawPointer
    var value1: T
    var value2: T
}

最終完整的仿寫(xiě)代碼為

//2怪瓶、閉包捕獲多個(gè)值的原理
struct HeapObject {
    var type: UnsafeRawPointer
    var refCount1: UInt32
    var refCount2: UInt32
}

//函數(shù)返回值結(jié)構(gòu)體
//BoxType 是一個(gè)泛型萧落，最終是由傳入的Box決定的
struct FunctionData<BoxType>{
    var ptr: UnsafeRawPointer//內(nèi)嵌函數(shù)地址
    var captureValue: UnsafePointer<BoxType>
}

//捕獲值的結(jié)構(gòu)體
struct Box<T> {
    var refCounted: HeapObject
    //valueBox用于存儲(chǔ)Box類(lèi)型
    var valueBox: UnsafeRawPointer
    var value: T
    var value2: T
}

//封裝閉包的結(jié)構(gòu)體，目的是為了使返回值不受影響
struct VoidIntFun {
    var f: () ->Int
}

//下面代碼的打印結(jié)果是什么洗贰？
func makeIncrementer(forIncrement amount: Int, amount2: Int) -> () -> Int{
    var runningTotal = 12
    //內(nèi)嵌函數(shù)找岖，也是一個(gè)閉包
    func incrementer() -> Int{
        runningTotal += amount
        runningTotal += amount2
        return runningTotal
    }
    return incrementer
}
var makeInc = makeIncrementer(forIncrement: 10, amount2: 18)
var f = VoidIntFun(f: makeInc)

let ptr = UnsafeMutablePointer<VoidIntFun>.allocate(capacity: 1)
//初始化的內(nèi)存空間
ptr.initialize(to: f)
//將ptr重新綁定內(nèi)存
let ctx = ptr.withMemoryRebound(to: FunctionData<Box<Int>>.self, capacity: 1) {
     $0.pointee
}
print(ctx.ptr)
print(ctx.captureValue)
print(ctx.captureValue.pointee)

總結(jié)

• 1、捕獲值原理：在堆上開(kāi)辟內(nèi)存空間敛滋，并將捕獲的值放到這個(gè)內(nèi)存空間里
• 2许布、修改捕獲值時(shí)：實(shí)質(zhì)是修改堆空間的值
• 3、閉包是一個(gè)引用類(lèi)型（引用類(lèi)型是地址傳遞）绎晃，閉包的底層結(jié)構(gòu)（是結(jié)構(gòu)體：函數(shù)地址 + 捕獲變量的地址 == 閉包）
• 4蜜唾、函數(shù)也是一個(gè)引用類(lèi)型（本質(zhì)是一個(gè)結(jié)構(gòu)體杂曲，其中只保存了函數(shù)的地址），例如還是以makeIncrementer函數(shù)為例

func makeIncrementer(inc: Int) -> Int{
    var runningTotal = 1
    return runningTotal + inc
}

var makeInc = makeIncrementer

分析其IR代碼袁余，函數(shù)在傳遞過(guò)程中擎勘，傳遞的就是函數(shù)的地址

image

將仿寫(xiě)的FunctionData進(jìn)行修改

struct FunctionData{
    var ptr: UnsafeRawPointer//內(nèi)嵌函數(shù)地址
    var captureValue: UnsafePointer<BoxType>
}

然后改版后的結(jié)構(gòu)仿寫(xiě)如下

//函數(shù)也是引用類(lèi)型
struct FunctionData{
    //函數(shù)地址
    var ptr: UnsafeRawPointer
    var captureValue: UnsafeRawPointer?
}

//封裝閉包的結(jié)構(gòu)體，目的是為了使返回值不受影響
struct VoidIntFun {
    var f: (Int) ->Int
}

func makeIncrementer(inc: Int) -> Int{
    var runningTotal = 1
    return runningTotal + inc
}

var makeInc = makeIncrementer
var f = VoidIntFun(f: makeInc)

let ptr = UnsafeMutablePointer<VoidIntFun>.allocate(capacity: 1)
//初始化的內(nèi)存空間
ptr.initialize(to: f)
//將ptr重新綁定內(nèi)存
let ctx = ptr.withMemoryRebound(to: FunctionData.self, capacity: 1) {
     $0.pointee
}

print(ctx.ptr)
print(ctx.captureValue)

<!--打印結(jié)果-->
0x0000000100002140
nil

通過(guò)cat命令查看該地址泌霍，地址就是makeIncrementer函數(shù)的地址

image

總結(jié)

• 一個(gè)閉包能夠從上下文中捕獲已經(jīng)定義的常量/變量货抄，即使其作用域不存在了述召，閉包仍然能夠在其函數(shù)體內(nèi)引用朱转、修改

  • 1、每次修改捕獲值：本質(zhì)修改的是堆區(qū)中的value值
  • 2积暖、每次重新執(zhí)行當(dāng)前函數(shù)藤为，會(huì)重新創(chuàng)建新的內(nèi)存空間

• 捕獲值原理：本質(zhì)是在堆區(qū)開(kāi)辟內(nèi)存空間，并將捕獲值存儲(chǔ)到這個(gè)內(nèi)存空間

• 閉包是一個(gè)引用類(lèi)型（本質(zhì)是函數(shù)地址傳遞）夺刑，底層結(jié)構(gòu)為：閉包 = 函數(shù)地址 + 捕獲變量的地址

• 函數(shù)也是引用類(lèi)型（本質(zhì)是結(jié)構(gòu)體缅疟，其中保存了函數(shù)的地址）