Swift中的指針?lè)譃閮深?lèi)

• Raw Pointer：未指定數(shù)據(jù)類(lèi)型的指針 (原?指針)覆旭，表示為UnsafeRawPointer
• Type Pointer：指定數(shù)據(jù)類(lèi)型指針樊销，表示為UnsafePointer<T>

Swift中的指針和OC中指針的對(duì)應(yīng)關(guān)系：

指針的使用是不安全的弄兜，從unsafe開(kāi)頭的命名來(lái)看就知道州泊。內(nèi)存需要開(kāi)發(fā)者手動(dòng)管理，使用完需要手動(dòng)釋放乾蛤。操作不當(dāng)就會(huì)crash邑滨，請(qǐng)開(kāi)發(fā)者慎重使用日缨。

Raw Pointer（原?指針）

//RawPionter的使用

//1、分配32字節(jié)的內(nèi)存空間大小掖看，指定8字節(jié)對(duì)齊方式
let p = UnsafeMutableRawPointer.allocate(byteCount: 32, alignment: 8)

//2匣距、advanced代表當(dāng)前 p 前進(jìn)的步長(zhǎng)面哥，對(duì)于 RawPointer 來(lái)說(shuō)，我們需要移動(dòng)的是當(dāng)前存儲(chǔ)值得內(nèi)存大小毅待，即 MemoryLayout.stride
//3尚卫、storeBytes: 這里就是存儲(chǔ)我們當(dāng)前的數(shù)據(jù)，這里需要指定我們當(dāng)前數(shù)據(jù)的類(lèi)型
for i in 0..<4{
    //存儲(chǔ)
    p.advanced(by: i * 8).storeBytes(of: i + 1, as: Int.self)
}

//4尸红、load顧明思義是加載吱涉，fromBytesOffe：是相對(duì)于我們當(dāng)前 p 的首地址的偏移
for i in 0..<4{
    //讀取
    let value = p.load(fromByteOffset: i * 8, as: Int.self)
    print("index\(i),value:\(value)")
}

p.deallocate()

//輸出以下內(nèi)容：
//index0,value:1
//index1,value:2
//index2,value:3
//index3,value:4

上述代碼中，循環(huán)存儲(chǔ)時(shí)使用p.advanced(by: i * 8)外里，因?yàn)?code>Raw Pointer并不知道指針的具體類(lèi)型怎爵，所以必須指定好每次移動(dòng)的步長(zhǎng)，所以是i * 8

Type Pointer

withUnsafePointer方法的定義

withUnsafePointer方法的定義

body參數(shù)傳入的是閉包表達(dá)式盅蝗，然后通過(guò)rethrows重新拋出Result鳖链，也就是閉包表達(dá)式產(chǎn)生的結(jié)果。所以可以簡(jiǎn)寫(xiě)閉包表達(dá)式的參數(shù)及返回值墩莫，其中$0表示第一個(gè)參數(shù)芙委，相當(dāng)于ptr。更多參數(shù)依次使用$0狂秦、$1灌侣、$2...

var age = 10
//完整寫(xiě)法
let p1 = withUnsafePointer(to: &age) { ptr in
    return ptr
}
//簡(jiǎn)化ptr
let p2 = withUnsafePointer(to: &age) {
    return $0
}
//簡(jiǎn)化ptr、return
let p3 = withUnsafePointer(to: &age) { $0 }

print(p1)
print(p2)
print(p3)

//輸出以下內(nèi)容：
//0x00000001000081a0
//0x00000001000081a0
//0x00000001000081a0

通過(guò)pointee屬性可以訪問(wèn)指針值

var age = 10
let p = withUnsafePointer(to: &age){ $0 }
print("p.pointee：\(p.pointee)")

//輸出以下內(nèi)容：
//p.pointee：10

修改age變量值的幾種方式

var age = 10
age = withUnsafePointer(to: &age){ ptr in
    return ptr.pointee + 12
}

print("age：\(age)")

//輸出以下內(nèi)容：
//age：22

上述代碼在閉包中return結(jié)果給age故痊，屬于間接修改

var age = 10
withUnsafeMutablePointer(to: &age){ ptr in
    ptr.pointee += 12
}

print("age：\(age)")

//輸出以下內(nèi)容：
//age：22

上述代碼通過(guò)withUnsafeMutablePointer方法顶瞳，在閉包中修改指針的值玖姑，屬于直接修改

在閉包中對(duì)指針及其所指向的內(nèi)容修改愕秫，不能使用withUnsafePointer，它是不可變方法焰络，編譯報(bào)錯(cuò)

編譯報(bào)錯(cuò)

另一種創(chuàng)建Type Pointer的方式

var age = 10

//1戴甩、capacity:容量大小，當(dāng)前的大小為 1 * 8字節(jié)
let ptr = UnsafeMutablePointer<Int>.allocate(capacity: 1)

//2闪彼、初始化當(dāng)前的 UnsafeMutablePointer<Int> 指針
ptr.initialize(to: age)

//3甜孤、下面兩個(gè)成對(duì)調(diào)用，管理內(nèi)存
ptr.deinitialize(count: 1)

ptr.pointee+=12
print("ptr.pointee：\(ptr.pointee)")

ptr.deallocate()

//輸出以下內(nèi)容：
//ptr.pointee：22

上述代碼通過(guò)allocate創(chuàng)建UnsafeMutablePointer

• initialize方法和deinitialize方法必須成對(duì)出現(xiàn)
• allocate方法和deallocate方法必須成對(duì)出現(xiàn)
• deinitialize方法的count值畏腕，必須和allocate方法分配容量大小的capacity值保持一致

案例1：

訪問(wèn)類(lèi)型指針的不同方式

struct LGTeacher {
    var width : Double
    var height : Double
}

var t1 = LGTeacher(width: 10, height: 1.85)
var t2 = LGTeacher(width: 20, height: 1.75)
var t3 = LGTeacher(width: 30, height: 1.65)
var t4 = LGTeacher(width: 40, height: 1.55)

let ptr=UnsafeMutablePointer<LGTeacher>.allocate(capacity: 4);

ptr.initialize(to: t1)
//1缴川、通過(guò) (ptr+i) 移動(dòng)內(nèi)存
(ptr+1).initialize(to: t2)
//2、通過(guò) advanced(by: i) 移動(dòng)內(nèi)存
ptr.advanced(by: 2).initialize(to: t3)
//3描馅、通過(guò) successor() 移動(dòng)內(nèi)存
ptr.successor().successor().successor().initialize(to: t4)

ptr.deinitialize(count: 4)

//1把夸、通過(guò)索引下標(biāo)訪問(wèn)值
print(ptr[0])
//2、通過(guò) (ptr+i) 訪問(wèn)指針
print((ptr+1).pointee)
//3铭污、通過(guò) advanced(by: i) 訪問(wèn)指針
print(ptr.advanced(by: 2).pointee)
//4恋日、通過(guò) successor() 訪問(wèn)指針
print(ptr.successor().successor().successor().pointee)

ptr.deallocate()

//輸出以下內(nèi)容：
//LGTeacher(width: 10.0, height: 1.85)
//LGTeacher(width: 20.0, height: 1.75)
//LGTeacher(width: 30.0, height: 1.65)
//LGTeacher(width: 40.0, height: 1.55)

上述代碼中膀篮，訪問(wèn)指針的方式有很多種，但要特別留意advanced方式：Type Pointer使用advanced訪問(wèn)指針岂膳，和Raw Pointer有明顯區(qū)別誓竿；Type Pointer已經(jīng)知道指針的類(lèi)型，使用advanced只需告訴指針前進(jìn)步數(shù)即可谈截，所以只需傳入1筷屡、2、3...

案例2：

將類(lèi)的實(shí)例對(duì)象綁定到結(jié)構(gòu)體的內(nèi)存中

struct HeapObject {
    var kind: UnsafeRawPointer
    var strongref: UInt32
    var unownedRef: UInt32
}

class LGTeacher{
    var age = 18
}

var t=LGTeacher()

//拿到實(shí)例對(duì)象的指針
let ptr = Unmanaged.passUnretained(t as AnyObject).toOpaque()
//將指針內(nèi)存綁定給結(jié)構(gòu)體
let heapObject=ptr.bindMemory(to: HeapObject.self, capacity: 1)

print(heapObject.pointee)

//輸出以下內(nèi)容：
//HeapObject(kind: 0x00000001000081f8, strongref: 2, unownedRef: 0)

• 使用Unmanaged托管指針傻盟，指定內(nèi)存管理速蕊，類(lèi)似于OC與CF交互方式（__bridge所有權(quán)的轉(zhuǎn)換）
  passUnretained：不增加引用計(jì)數(shù)，不需要獲取所有權(quán)
  passRetained：增加引用計(jì)數(shù)娘赴，需要獲取所有權(quán)
  toOpaque：不透明的指針规哲，返回UnsafeMutableRawPointer
• bindMemory：更改內(nèi)存綁定的類(lèi)型，返回UnsafeMutablePointer<T>
  如果之前沒(méi)有綁定诽表，就是?次綁定
  如果綁 定過(guò)了唉锌，會(huì)被重新綁定為該類(lèi)型

案例3：

將kind對(duì)象綁定到結(jié)構(gòu)體的內(nèi)存中

struct lg_swift_class {
    var kind: UnsafeRawPointer
    var superClass: UnsafeRawPointer
    var cachedata1: UnsafeRawPointer
    var cachedata2: UnsafeRawPointer
    var data: UnsafeRawPointer
    var flags: UInt32
    var instanceAddressOffset: UInt32
    var instanceSize: UInt32
    var instanceAlignMask: UInt16
    var reserved: UInt16
    var classSize: UInt32
    var classAddressOffset: UInt32
    var description: UnsafeRawPointer
}

//承接案例2代碼
let metaPtr=heapObject.pointee.kind.bindMemory(to: lg_swift_class.self, capacity: 1)

print(metaPtr.pointee)

//輸出以下內(nèi)容：
//lg_swift_class(kind: 0x00000001000081d0, superClass: 0x00007fff93abb020, cachedata1: 0x00007fff6c2c2140, cachedata2: 0x0000002000000000, data: 0x00000001005307e2, flags: 2, instanceAddressOffset: 0, instanceSize: 24, instanceAlignMask: 7, reserved: 0, classSize: 136, classAddressOffset: 16, description: 0x0000000100003bec)

上述代碼中，本質(zhì)上metaPtr和lg_swift_class的內(nèi)存結(jié)構(gòu)是一樣的竿奏，可以直接將內(nèi)存地址綁定到結(jié)構(gòu)體上袄简。因?yàn)楫?dāng)前內(nèi)存中的分布是一樣的，自然可以拿到內(nèi)存結(jié)構(gòu)里的指針泛啸。

案例4：

元組指針類(lèi)型轉(zhuǎn)換

思考下面代碼绿语，如何將tul元組類(lèi)型，傳入testPointer方法

如何將元組類(lèi)型傳入testPointer方法

Swift是類(lèi)型安全的語(yǔ)言候址，tul是元組類(lèi)型吕粹，和testPointer方法的ptr參數(shù)UnsafePointer<Int>類(lèi)型對(duì)應(yīng)不上，直接方法調(diào)用肯定是不行的岗仑，編譯報(bào)錯(cuò)

直接傳遞tul變量

使用withUnsafePointer拿到tul的指針匹耕，但類(lèi)型是UnsafePointer<(Int, Int)>，和testPointer方法的ptr參數(shù)UnsafePointer<Int>類(lèi)型依然對(duì)應(yīng)不上荠雕，直接方法調(diào)用稳其，編譯報(bào)錯(cuò)

傳遞UnsafePointer<(Int, Int)>類(lèi)型

正確方案的演示：

var tul = (10, 20)

func testPointer(_ ptr : UnsafePointer<Int>) {
    print(ptr.pointee)
    print(ptr.successor().pointee)
}

withUnsafePointer(to: &tul){ (tulPtr: UnsafePointer<(Int, Int)>) in
    let ptr = UnsafeRawPointer(tulPtr).assumingMemoryBound(to: Int.self)
    testPointer(ptr)
}

//輸出以下內(nèi)容：
//10
//20

上述代碼中，不能使用bindMemory炸卑，因?yàn)?code>tulPtr指針已經(jīng)綁定到具體內(nèi)存中既鞠。這里使用assumingMemoryBound，假定內(nèi)存綁定盖文，告訴編譯器tulPtr就是我指定的類(lèi)型嘱蛋，不用檢查了

本質(zhì)上UnsafePointer<(Int, Int)>在內(nèi)存空間里存儲(chǔ)的就是兩個(gè)Int，占據(jù)16字節(jié)，對(duì)于指針來(lái)說(shuō)就是Int類(lèi)型的指針UnsafePointer<Int>

案例5：

獲取結(jié)構(gòu)體屬性的指針

思考下面代碼浑槽，如何將結(jié)構(gòu)體屬性t.strongref和t.unownedRef蒋失，傳入testPointer方法

如何將結(jié)構(gòu)體屬性傳入testPointer方法

如果先通過(guò)withUnsafePointer(to: &t)獲取ptr
再通過(guò)withUnsafePointer(to: &ptr.pointee.strongref)獲取strongRefPtr

只讀屬性ptr.pointee不能作為inout參數(shù)傳遞

如圖：此方案是行不通的，因?yàn)?code>ptr.pointee是只讀屬性桐玻，所以不能作為inout參數(shù)傳遞篙挽，編譯報(bào)錯(cuò)

正確方案的演示：

struct HeapObject {
    var strongref = 10
    var unownedRef = 20
}

var t = HeapObject()

func testPointer(_ ptr : UnsafePointer<Int>) {
    print(ptr.pointee)
}

withUnsafePointer(to: &t){ (ptr : UnsafePointer<HeapObject>) in
    
    let strongRefPtr = UnsafeRawPointer(ptr) + MemoryLayout<HeapObject>.offset(of: \HeapObject.strongref)!
    testPointer(strongRefPtr.assumingMemoryBound(to: Int.self))
    
    let unownedRefPtr = UnsafeRawPointer(ptr) + MemoryLayout<HeapObject>.offset(of: \HeapObject.unownedRef)!
    testPointer(unownedRefPtr.assumingMemoryBound(to: Int.self))
}

//輸出以下內(nèi)容：
//10
//20

將結(jié)構(gòu)體指針轉(zhuǎn)換成原生指針，移動(dòng)內(nèi)存地址找到結(jié)構(gòu)體屬性指針镊靴，再通過(guò)assumingMemoryBound假定內(nèi)存綁定铣卡，告訴編譯器結(jié)構(gòu)體屬性指針為Int類(lèi)型

案例6：

使用withMemoryRebound臨時(shí)更改內(nèi)存綁定類(lèi)型

和案例4的情況一樣，方法參數(shù)類(lèi)型偏竟，與傳入?yún)?shù)類(lèi)型不一致煮落，編譯報(bào)錯(cuò)

方法參數(shù)與傳入?yún)?shù)類(lèi)型不一致

正確方案的演示：

var age : Int = 10

func testPointer(_ ptr : UnsafePointer<UInt64>) {
    print(ptr.pointee)
}

let ptr = withUnsafePointer(to: &age){ $0 }

ptr.withMemoryRebound(to: UInt64.self, capacity: 1) { (ptr : UnsafePointer<UInt64>) in
    testPointer(ptr)
}

//輸出以下內(nèi)容：
//10

使用withMemoryRebound將ptr臨時(shí)更改為UnsafePointer<UInt64>類(lèi)型，出了withMemoryRebound方法作用域踊谋，ptr依然是UnsafePointer<Int>類(lèi)型

總結(jié)：

• Swift中的指針?lè)譃閮深?lèi)
  Raw pointer：未指定數(shù)據(jù)類(lèi)型的指針 (原?指針)蝉仇，表示為UnsafeRawPointer
Type pointer：指定數(shù)據(jù)類(lèi)型指針，表示為UnsafePointer<T>
• 指針的使用是不安全的殖蚕，操作不當(dāng)就會(huì)crash轿衔，一定要小心謹(jǐn)慎的使用
• bindMemory：更改內(nèi)存綁定的類(lèi)型
  如果之前沒(méi)有綁定，就是?次綁定
  如果綁 定過(guò)了睦疫，會(huì)被重新綁定為該類(lèi)型
• assumingMemoryBound：假定內(nèi)存綁定害驹，告訴編譯器就是我指定的類(lèi)型，不需要檢查
• withMemoryRebound：臨時(shí)更改內(nèi)存綁定類(lèi)型