本文主要介紹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是當前內(nèi)存的首地址亿虽，通過內(nèi)存平移來獲取值
    let value = p.load(fromByteOffset: i * 8, as: Int.self)
    print("index: \(i), value: \(value)")
}

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

// ***** 運行結(jié)果 *****
index: 0, value: 4
index: 1, value: 0
index: 2, value: 140735374098444
index: 3, value: 140735324939864

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

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

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

修改后運行結(jié)果如下所示：

image

type pointer

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

• 查看withUnsafePointer(to:)的定義中，第二個參數(shù)傳入的是閉包表達式此再，然后通過rethrows重新拋出Result（即閉包表達式產(chǎn)生的結(jié)果）昔搂，所以可以將閉包表達式進行簡寫（簡寫參數(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
}
print(p1)

image

由于withUnsafePointer方法中的閉包屬于單一表達式策吠，因此可以省略參數(shù)逛裤、返回值，直接使用$0奴曙，$0等價于ptr

訪問屬性

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

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

// ***** 運行結(jié)果 *****
10

如何改變age變量值

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

• 間接修改：需要在閉包中直接通過ptr.pointee修改并返回炉菲。類似于char *p = "Sunrise" 中的 *p，因為訪問Sunrise通過*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 SunriseTeacher {
    var age = 18
    var height = 1.85
}
var t = SunriseTeacher()

• 使用UnsafeMutablePointer創(chuàng)建指針薪介，并通過指針訪問SunriseTeacher實例對象祠饺，有以下三種方式：
  • 方式一：下標訪問
  • 方式二：內(nèi)存平移
  • 方式三：successor

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

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

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

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

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

// ***** 運行結(jié)果 *****
SunriseTeacher(age: 18, height: 1.85)
SunriseTeacher(age: 20, height: 1.88)
===
SunriseTeacher(age: 18, height: 1.85)
SunriseTeacher(age: 20, height: 1.88)
===
SunriseTeacher(age: 18, height: 1.85)
SunriseTeacher(age: 20, height: 1.88)
===

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

image

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

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

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

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

對比

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

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

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

• 這里的ptr如果使用advanced(by: MemoryLayout<SunriseTeacher>.stride)即16*16字節(jié)大小勺鸦，此時獲取的結(jié)果是有問題的，由于這里知道具體的類型目木，所以只需要標識指針前進 幾步即可换途，即advanced(by: 1)

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

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

定義如下代碼

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

class SunriseTeacher{
   var age = 18
}

var t = SunriseTeacher()

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

• 1军拟、獲取實例變量的內(nèi)存地址
• 2、綁定到結(jié)構(gòu)體內(nèi)存誓禁，返回值是UnsafeMutablePointer<T>
• 3懈息、訪問成員變量pointee.kind

// 將sunrise綁定到結(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.passRetained(sunrise as AnyObject).toOpaque()

// 2骇两、綁定到結(jié)構(gòu)體內(nèi)存,返回值是UnsafeMutablePointer<T>
/*
 - bindMemory 更改當前 UnsafeMutableRawPointer 的指針類型，綁定到具體的類型值
    - 如果沒有綁定姜盈，則綁定
    - 如果已經(jīng)綁定低千，則重定向到 HeapObject類型上
 */
let heapObject = ptr.bindMemory(to: HeapObject.self, capacity: 1)

// 3、訪問成員變量
print(heapObject.pointee)
print(heapObject.pointee.kind)
print(heapObject.pointee.strongRef)
print(heapObject.pointee.unknowedRef)

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

image

• create\copy 需要使用retain
• 不需要獲取所有權(quán) 使用unretain
• 將kind的類型改成UnsafeRawPointer示血，kind的輸出就是地址了

image

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

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

struct wrs_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
}

• 將sunrise改成綁定到wrs_swift_class

// 1、綁定到cjl_swift_class
let metaPtr = heapObject.pointee.kind.bindMemory(to: wrs_swift_class.self, capacity: 1)
// 2救拉、訪問
print(metaPtr.pointee)

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

image

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

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

image

解決辦法：通過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)存綁定蒂萎，這里就是告訴編譯器：我的類型就是這個秆吵，你不要檢查我了,其實際類型還是原來的類型