本文主要介紹swift中的指針

swift中的指針分為兩類

• typed pointer 指定數(shù)據(jù)類型指針骑丸，即 UnsafePointer<T>,其中T表示泛型

• raw pointer 未指定數(shù)據(jù)類型的指針（原生指針） ，即UnsafeRawPointer

swift與OC指針對比如下：

原生指針

原生指針：是指未指定數(shù)據(jù)類型的指針恭取，有以下說明

• 對于指針的內(nèi)存管理是需要手動管理的

• 指針在使用完需要手動釋放

有以下一段原生指針的使用代碼泰偿，請問運行時會發(fā)生什么？

//原生指針
//對于指針的內(nèi)存管理是需要手動管理的
//定義一個未知類型的指針：本質(zhì)是分配32字節(jié)大小的空間蜈垮，指定對齊方式是8字節(jié)對齊
let p = UnsafeMutableRawPointer.allocate(byteCount: 32, alignment: 8)

//存儲
for i in 0..<4 {
    p.storeBytes(of: i + 1, as: Int.self)
}
//讀取
for i in 0..<4 {
    //p是當(dāng)前內(nèi)存的首地址耗跛，通過內(nèi)存平移來獲取值
    let value = p.load(fromByteOffset: i * 8, as: Int.self)
    print("index: \(i), value: \(value)")
}

//使用完成需要dealloc，即需要手動釋放
p.deallocate()

• 通過運行發(fā)現(xiàn)攒发，在讀取數(shù)據(jù)時有問題调塌，原因是因為讀取時指定了每次讀取的大小，但是存儲是直接在8字節(jié)的p中存儲了i+1惠猿，即可以理解為并沒有指定存儲時的內(nèi)存大小

• 修改：通過advanced(by:)指定存儲時的步長

//存儲
for i in 0..<4 {
    //指定當(dāng)前移動的步數(shù)羔砾，即i * 8
    p.advanced(by: i * 8).storeBytes(of: i + 1, as: Int.self)
}

修改后的運行結(jié)果如下

type pointer

在前幾篇文章中，我們獲取基本數(shù)據(jù)類型的地址是通過withUnsafePointer(to:)方法獲取的

• 查看withUnsafePointer(to:的定義中偶妖，第二個參數(shù)傳入的是閉包表達(dá)式姜凄，然后通過rethrows重新拋出Result（即閉包表達(dá)式產(chǎn)生的結(jié)果）了，所以可以將閉包表達(dá)式進(jìn)行簡寫(簡寫參數(shù)餐屎、返回值)檀葛，其中$0表示第一個參數(shù)玩祟，$1表示第二個參數(shù)腹缩，以此類推

<!--定義-->
@inlinable public func withUnsafePointer<T, Result>(to value: inout T, _ body: (UnsafePointer<T>) throws -> Result) rethrows -> Result

<!--使用1-->
var age = 10
let p = withUnsafePointer(to: &age) { $0 }
print(p)

<!--使用2-->
withUnsafePointer(to: &age){print($0)}

<!--使用3-->
//其中p1的類型是 UnsafePointer<Int>
let p1 = withUnsafePointer(to: &age) { ptr in
    return ptr
}

由于withUnsafePointer方法中的閉包屬于單一表達(dá)式，因此可以省略參數(shù)、返回值藏鹊，直接使用$0润讥，$0等價于ptr

訪問屬性

可以通過指針的pointee屬性訪問變量值，如下所示

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

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

如何改變age變量值盘寡？

改變變量值的方式有兩種楚殿，一種是間接修改，一種是直接修改

• 間接修改：需要在閉包中直接通過ptr.pointee修改并返回竿痰。類似于char *p = “CJL” 中的 *p脆粥，因為訪問CJL通過 *p

var age = 10
age = withUnsafePointer(to: &age) { ptr in
    //返回Int整型值
    return ptr.pointee + 12
}
print(age)

• 直接修改-方式1：也可以通過withUnsafeMutablePointer方法，即創(chuàng)建方式一

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

• 直接修改方式2：通過allocate創(chuàng)建UnsafeMutablePointer影涉，需要注意的是

  • initialize 與 deinitialize是成對的

  • deinitialize中的count與申請時的capacity需要一致

  • 需要deallocate

var age = 10
//分配容量大小变隔，為8字節(jié)
let ptr = UnsafeMutablePointer<Int>.allocate(capacity: 1)
//初始化
ptr.initialize(to: age)
ptr.deinitialize(count: 1)

ptr.pointee += 12
print(ptr.pointee)

//釋放
ptr.deallocate()

指針實例應(yīng)用

實戰(zhàn)1：訪問結(jié)構(gòu)體實例對象

定義一個結(jié)構(gòu)體

struct CJLTeacher {
    var age = 10
    var height = 1.85
}
var t = CJLTeacher()

• 使用UnsafeMutablePointer創(chuàng)建指針，并通過指針訪問CJLTeacher實例對象蟹倾，有以下三種方式：

  • 方式一：下標(biāo)訪問

  • 方式二：內(nèi)存平移

  • 方式三：successor

//分配兩個CJLTeacher大小的空間
let ptr = UnsafeMutablePointer<CJLTeacher>.allocate(capacity: 2)
//初始化第一個空間
ptr.initialize(to: CJLTeacher())
//移動匣缘，初始化第2個空間
ptr.successor().initialize(to: CJLTeacher(age: 20, height: 1.75))

//訪問方式一
print(ptr[0])
print(ptr[1])

//訪問方式二
print(ptr.pointee)
print((ptr+1).pointee)

//訪問方式三
print(ptr.pointee)
//successor 往前移動
print(ptr.successor().pointee)

//必須和分配是一致的
ptr.deinitialize(count: 2)
//釋放
ptr.deallocate()

需要注意的是，第二個空間的初始化不能通過advanced(by: MemoryLayout<CJLTeacher>.stride)去訪問鲜棠，否則取出結(jié)果是有問題

• 可以通過ptr + 1或者successor() 或者advanced(by: 1)

<!--第2個初始化 方式一-->
(ptr + 1).initialize(to: CJLTeacher(age: 20, height: 1.75))

<!--第2個初始化 方式二-->
ptr.successor().initialize(to: CJLTeacher(age: 20, height: 1.75))

<!--第2個初始化 方式三-->
ptr.advanced(by: 1).initialize(to:  CJLTeacher(age: 20, height: 1.75))

對比

• 這里p使用advanced(by: i * 8)肌厨，是因為此時并不知道 p 的具體類型，必須指定每次移動的步長

let p = UnsafeMutableRawPointer.allocate(byteCount: 32, alignment: 8)

//存儲
for i in 0..<4 {
    //指定當(dāng)前移動的步數(shù)豁陆，即i * 8
    p.advanced(by: i * 8).storeBytes(of: i + 1, as: Int.self)
}

• 這里的ptr如果使用advanced(by: MemoryLayout<CJLTeacher>.stride)即16*16字節(jié)大小柑爸，此時獲取的結(jié)果是有問題的，由于這里知道具體的類型盒音，所以只需要標(biāo)識指針前進(jìn) 幾步即可竖配，即advanced(by: 1)

let ptr = UnsafeMutablePointer<CJLTeacher>.allocate(capacity: 2)
//初始化第一個空間
ptr.initialize(to: CJLTeacher())
//移動，初始化第2個空間
ptr.advanced(by: 1).initialize(to:  CJLTeacher(age: 20, height: 1.75))

實戰(zhàn)2：實例對象綁定到struct內(nèi)存

定義如下代碼

struct HeapObject {
    var kind: Int
    var strongRef: UInt32
    var unownedRef: UInt32
}

class CJLTeacher{
    var age = 18
}

var t = CJLTeacher()

demo1：類的實例對象如何綁定到 結(jié)構(gòu)體內(nèi)存中里逆？

• 1进胯、獲取實例變量的內(nèi)存地址
• 2、綁定到結(jié)構(gòu)體內(nèi)存,返回值是UnsafeMutablePointer<T>
• 3原押、訪問成員變量 pointee.kind

//將t綁定到結(jié)構(gòu)體內(nèi)存中
//1胁镐、獲取實例變量的內(nèi)存地址，聲明成了非托管對象
/*
 通過Unmanaged指定內(nèi)存管理诸衔，類似于OC與CF的交互方式（所有權(quán)的轉(zhuǎn)換 __bridge）
 - passUnretained 不增加引用計數(shù)盯漂，即不需要獲取所有權(quán)
 - passRetained 增加引用計數(shù)，即需要獲取所有權(quán)
 - toOpaque 不透明的指針
 */

let ptr = Unmanaged.passUnretained(t as AnyObject).toOpaque()
//2笨农、綁定到結(jié)構(gòu)體內(nèi)存,返回值是UnsafeMutablePointer<T>
/*
 - bindMemory 更改當(dāng)前 UnsafeMutableRawPointer 的指針類型就缆，綁定到具體的類型值
    - 如果沒有綁定，則綁定
    - 如果已經(jīng)綁定谒亦，則重定向到 HeapObject類型上
 */
let heapObject = ptr.bindMemory(to: HeapObject.self, capacity: 1)
//3竭宰、訪問成員變量
print(heapObject.pointee.kind)
print(heapObject.pointee.strongRef)
print(heapObject.pointee.unownedRef)

其運行結(jié)果如下空郊，有點類似于CF與OC交互的時的所有權(quán)的轉(zhuǎn)換

• create\copy 需要使用retain

• 不需要獲取所有權(quán) 使用unretain

• 將kind的類型改成UnsafeRawPointer，kind的輸出就是地址了

demo2：綁定到類結(jié)構(gòu)

將swift中的類結(jié)構(gòu)定義成一個結(jié)構(gòu)體

struct cjl_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 flinstanceAlignMask: UInt16
    var reserved: UInt16
    var classSize: UInt32
    var classAddressOffset: UInt32
    var description: UnsafeRawPointer
}

• 將t改成綁定到cjl_swift_class

//1切揭、綁定到cjl_swift_class
let metaPtr = heapObject.pointee.kind.bindMemory(to: cjl_swift_class.self, capacity: 1)
//2狞甚、訪問
print(metaPtr.pointee)

運行結(jié)果如下，其本質(zhì)原因是因為 metaPtr 和 cjl_swift_class的類結(jié)構(gòu)是一樣的

實戰(zhàn)3：元組指針類型轉(zhuǎn)換

• 如果將元組傳給 函數(shù)testPointer廓旬，使用方式如下

var tul = (10, 20)

//UnsafePointer<T>
func testPointer(_ p : UnsafePointer<Int>){
    print(p)
}

withUnsafePointer(to: &tul) { (tulPtr: UnsafePointer<(Int, Int)>) in
    //不能使用bindMemory哼审，因為已經(jīng)綁定到具體的內(nèi)存中了
    //使用assumingMemoryBound，假定內(nèi)存綁定孕豹，目的是告訴編譯器ptr已經(jīng)綁定過Int類型了涩盾，不需要再檢查memory綁定
    testPointer(UnsafeRawPointer(tulPtr).assumingMemoryBound(to: Int.self))
}

• 或者告訴編譯器轉(zhuǎn)換成具體的類型

func testPointer(_ p: UnsafeRawPointer){
    p.assumingMemoryBound(to: Int.self)
}

實戰(zhàn)4：如何獲取結(jié)構(gòu)體的屬性的指針

• 1、定義實例變量
• 2励背、獲取實例變量的地址旁赊，并將strongRef的屬性值傳遞給函數(shù)

代碼如下：

struct HeapObject {
    var strongRef: UInt32 = 10
    var unownedRef: UInt32 = 20
}

func testPointer(_ p: UnsafePointer<Int>){
   print(p)
}
//實例化
var  t = HeapObject()
//獲取結(jié)構(gòu)體屬性的指針傳入函數(shù)
withUnsafePointer(to: &t) { (ptr: UnsafePointer<HeapObject>) in
    //獲取變量
    let strongRef = UnsafeRawPointer(ptr) + MemoryLayout<HeapObject>.offset(of: \HeapObject.strongRef)!
    //傳遞strongRef屬性的值
    testPointer(strongRef.assumingMemoryBound(to: Int.self))
}

實戰(zhàn)5：通過 withMemoryRebound 臨時綁定內(nèi)存類型

• 如果方法的類型與傳入?yún)?shù)的類型不一致，會報錯

解決辦法：通過withMemoryRebound臨時綁定內(nèi)存類型

var age = 10
func testPointer(_ p: UnsafePointer<Int64>){
   print(p)
}
let ptr = withUnsafePointer(to: &age) {$0}
ptr.withMemoryRebound(to: Int64.self, capacity: 1) { (ptr: UnsafePointer<Int64>)  in
    testPointer(ptr)
}

總結(jié)

• 指針類型分兩種

  • typed pointer 指定數(shù)據(jù)類型指針椅野，即 UnsafePointer<T> + unsafeMutablePointer

  • raw pointer 未指定數(shù)據(jù)類型的指針（原生指針） 终畅，即UnsafeRawPointer + unsafeMutableRawPointer

• withMemoryRebound: 臨時更改內(nèi)存綁定類型

• bindMemory(to: Capacity:): 更改內(nèi)存綁定的類型，如果之前沒有綁定竟闪，那么就是首次綁定离福，如果綁定過了，會被重新綁定為該類型

• assumingMemoryBound假定內(nèi)存綁定炼蛤，這里就是告訴編譯器：我的類型就是這個妖爷，你不要檢查我了,其實際類型還是原來的類型