Swift進階雜談5:指針

今天簡單介紹一下swift中的指針swift

swift中的指針分爲兩類markdown

typed pointer 指定數據類型指針，即UnsafePointer<T>,其中T表示泛型
raw pointer 未指定數據類型的指針（原生指針），即UnsafeRawPointer

swift與OC指針對好比下：閉包

swift	OC	說明
unsafePointer< T >	const T *	指針及所指向的內容都不可變
unsafeMutablePointer	T *	指針及其所指向的內存內容都可變
unsafeRawPointer	const void *	指針指向未知類型
unsafeMutableRawPointer	void *	指針指向未知類型

原生指針

原生指針：是指未指定數據類型的指針，有如下說明ide

對於指針的內存管理是須要手動管理的
指針在使用完須要手動釋放

有如下一段原生指針的使用代碼，請問運行時會發生什麼？函數

//原生指針
//對於指針的內存管理是須要手動管理的
//定義一個未知類型的指針：本質是分配32字節大小的空間，指定對齊方式是8字節對齊
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是當前內存的首地址，經過內存平移來獲取值
    let value = p.load(fromByteOffset: i * 8, as: Int.self)
    print("index: \(i), value: \(value)")
}

//使用完成須要dealloc，即須要手動釋放
p.deallocate()
複製代碼

經過運行發現，在讀取數據時有問題，緣由是由於讀取時指定了每次讀取的大小，可是存儲在直接8字節的p中存儲了i+1，便可以理解爲並無指定存儲時的內存大小

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

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

修改後的運行結果以下 spa

type pointer

在以前的文章中，咱們獲取基本數據類型的地址是經過withUnsafePointer(to:)方法獲取的3d

查看withUnsafePointer(to:)的定義中，第二個參數傳入的是閉包表達式，而後經過rethrows從新拋出Result（即閉包表達式產生的結果）了，因此能夠將閉包表達式進行簡寫（簡寫參數、返回值），其中$0表示第一個參數，$1表示第二個參數，以此類推

<!--定義-->
@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方法中的閉包屬於單一表達式，所以能夠忽略參數、返回值，直接使用$0，$0等價於ptr。指針

訪問屬性

能夠經過指針的pointee屬性訪問變量值，以下所示code

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

<!--打印結果-->
10
複製代碼

如何改變age變量值？ 改變變量值的方式有兩種，一種是間接修改，一種是直接修改orm

間接修改：須要在閉包中直接經過ptr.pointee修改並返回。相似於char *p = "PD"中的*p，由於訪問PD經過*p

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

直接修改-方式1:也能夠經過withUnsafemutablePointer方法，即建立方式一

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

直接修改方式2:經過allocate建立UnsafeMutablePointer，須要注意的是
- initialize 與deinitialize是成對的
- deinitialize中的count與申請時的capacity須要一致
- 須要deallicate

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

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

//釋放
ptr.deallocate()
複製代碼

指針實例應用

實戰1:訪問結構體實例對象

定義一個結構體

struct CJLTeacher {
    var age = 10
    var height = 1.85
}
var t = CJLTeacher()
複製代碼

使用UnsafeMutablePointer建立指針，並經過指針訪問CJLTeacher實例對象，有如下三種方式：
- 方式一：下標訪問
- 方式二：內存平移
- 方式三：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)去訪問，不然取出結果是有問題

能夠經過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 {
    //指定當前移動的步數，即i * 8
    p.advanced(by: i * 8).storeBytes(of: i + 1, as: Int.self)
}
複製代碼

這裏的ptr若是使用advanced(by: MemoryLayout<CJLTeacher>.stride)即16*16字節大小，此時獲取的結果是有問題的，因爲這裏知道具體的類型，因此只須要標識指針前進幾步便可，即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))
複製代碼

實戰2:實例對象綁定到struct內存

定義如下代碼

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

class CJLTeacher{
    var age = 18
}

var t = CJLTeacher()
複製代碼

demo1:類的實例對象如何綁定到結構體內存中

一、獲取實例變量的內存地址
二、綁定到結構體內存,返回值是UnsafeMutablePointer<T>
三、訪問成員變量 pointee.kind

//將t綁定到結構體內存中
//一、獲取實例變量的內存地址，聲明成了非託管對象
/*
 經過Unmanaged指定內存管理，相似於OC與CF的交互方式（全部權的轉換 __bridge）
 - passUnretained 不增長引用計數，即不須要獲取全部權
 - passRetained 增長引用計數，即須要獲取全部權
 - toOpaque 不透明的指針
 */

let ptr = Unmanaged.passUnretained(t as AnyObject).toOpaque()
//二、綁定到結構體內存,返回值是UnsafeMutablePointer<T>
/*
 - bindMemory 更改當前 UnsafeMutableRawPointer 的指針類型，綁定到具體的類型值
    - 若是沒有綁定，則綁定
    - 若是已經綁定，則重定向到 HeapObject類型上
 */
let heapObject = ptr.bindMemory(to: HeapObject.self, capacity: 1)
//三、訪問成員變量
print(heapObject.pointee.kind)
print(heapObject.pointee.strongRef)
print(heapObject.pointee.unownedRef)
複製代碼

其運行結果以下，有點相似於CF與OC交互的時的全部權的轉換

create\copy 須要使用retain
不須要獲取全部權使用unretain
將kind的類型改爲UnsafeRawPointer，kind的輸出就是地址了

demo2：綁定到類結構 將swift中的類結構定義成一個結構體

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

//一、綁定到cjl_swift_class
let metaPtr = heapObject.pointee.kind.bindMemory(to: cjl_swift_class.self, capacity: 1)
//二、訪問
print(metaPtr.pointee)
複製代碼

運行結果以下，其本質緣由是由於 metaPtr 和 cjl_swift_class的類結構是同樣的

實戰3：元組指針類型轉換

若是將元組傳給函數testPointer，使用方式以下

var tul = (10, 20)

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

withUnsafePointer(to: &tul) { (tulPtr: UnsafePointer<(Int, Int)>) in
    //不能使用bindMemory，由於已經綁定到具體的內存中了
    //使用assumingMemoryBound，假定內存綁定，目的是告訴編譯器ptr已經綁定過Int類型了，不須要再檢查memory綁定
    testPointer(UnsafeRawPointer(tulPtr).assumingMemoryBound(to: Int.self))
}
複製代碼

或者告訴編譯器轉換成具體的類型

func testPointer(_ p: UnsafeRawPointer){
    p.assumingMemoryBound(to: Int.self)
}
複製代碼

實戰4：如何獲取結構體的屬性的指針

一、定義實例變量
二、獲取實例變量的地址，並將strongRef的屬性值傳遞給函數

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

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

實戰5：經過 withMemoryRebound 臨時綁定內存類型

若是方法的類型與傳入參數的類型不一致，會報錯

解決辦法：經過withMemoryRebound臨時綁定內存類型

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)
}
複製代碼

總結

指針類型分兩種
- typed pointer 指定數據類型指針，即 UnsafePointer<T> + unsafeMutablePointer
- raw pointer 未指定數據類型的指針（原生指針），即UnsafeRawPointer + unsafeMutableRawPointer
withMemoryRebound: 臨時更改內存綁定類型
bindMemory(to: Capacity:): 更改內存綁定的類型，若是以前沒有綁定，那麼就是首次綁定，若是綁定過了，會被從新綁定爲該類型
assumingMemoryBound假定內存綁定，這裏就是告訴編譯器：個人類型就是這個，你不要檢查我了,其實際類型仍是原來的類型