Swift底層進(jìn)階--005：指針

Swift中的指針?lè)譃閮深?/p>

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

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

Swift Object-C 說(shuō)明
unsafeRawPointer const void * 指針指向未知類型
unsafeMutableRawPointer void * 指針指向未知類型
unsafePointer<T> const T * 指針及所指向的內(nèi)容都不可變
unsafeMutablePointer<T> T * 指針及其所指向的內(nèi)存內(nèi)容均可變

指針的使用是不安全的，從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ù)的類型
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并不知道指針的具體類型，所以必須指定好每次移動(dòng)的步長(zhǎng)，所以是i * 8

Type Pointer

withUnsafePointer方法的定義

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

var age = 10
//完整寫法
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)類型指針的不同方式

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)知道指針的類型，使用advanced只需告訴指針前進(jìn)步數(shù)即可，所以只需傳入1、2、3...

案例2：

將類的實(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)存管理，類似于OC與CF交互方式（__bridge所有權(quán)的轉(zhuǎn)換）
    passUnretained：不增加引用計(jì)數(shù)，不需要獲取所有權(quán)
    passRetained：增加引用計(jì)數(shù)，需要獲取所有權(quán)
    toOpaque：不透明的指針，返回UnsafeMutableRawPointer
  • bindMemory：更改內(nèi)存綁定的類型，返回UnsafeMutablePointer<T>
    如果之前沒(méi)有綁定，就是?次綁定
    如果綁 定過(guò)了，會(huì)被重新綁定為該類型
案例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：

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

思考下面代碼，如何將tul元組類型，傳入testPointer方法

如何將元組類型傳入testPointer方法

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

直接傳遞tul變量

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

傳遞UnsafePointer<(Int, Int)>類型

正確方案的演示：

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就是我指定的類型，不用檢查了

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

案例6：

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

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

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

正確方案的演示：

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>類型，出了withMemoryRebound方法作用域，ptr依然是UnsafePointer<Int>類型

總結(jié)：
  • Swift中的指針?lè)譃閮深?br> Raw pointer：未指定數(shù)據(jù)類型的指針 (原?指針)，表示為UnsafeRawPointer
    Type pointer：指定數(shù)據(jù)類型指針，表示為UnsafePointer<T>
  • 指針的使用是不安全的，操作不當(dāng)就會(huì)crash，一定要小心謹(jǐn)慎的使用
  • bindMemory：更改內(nèi)存綁定的類型
    如果之前沒(méi)有綁定，就是?次綁定
    如果綁 定過(guò)了，會(huì)被重新綁定為該類型
  • assumingMemoryBound：假定內(nèi)存綁定，告訴編譯器就是我指定的類型，不需要檢查
  • withMemoryRebound：臨時(shí)更改內(nèi)存綁定類型
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時(shí)請(qǐng)結(jié)合常識(shí)與多方信息審慎甄別。
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡(jiǎn)書系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。

友情鏈接更多精彩內(nèi)容