Swift-進階 04：指針

Swift 進階之路 文章匯總

Swift-進階 04：指針

本文主要介紹swift中的指針

swift中的指針分為兩類

  • typed pointer 指定數據類型指針，即 UnsafePointer<T>,其中T表示泛型

  • raw pointer 未指定數據類型的指針（原生指針） ，即UnsafeRawPointer

swift與OC指針對比如下：

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

原生指針

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

  • 對于指針的內存管理是需要手動管理的

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

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

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

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

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

    image

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

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

修改后的運行結果如下


image

type pointer

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

  • 查看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
}

image

由于withUnsafePointer方法中的閉包屬于單一表達式，因此可以省略參數、返回值，直接使用$0，$0等價于ptr

訪問屬性

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

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

<!--打印結果-->
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()

指針實例應用

實戰(zhàn)1：訪問結構體實例對象

定義一個結構體

struct CJLTeacher {
    var age = 10
    var height = 1.85
}
var t = CJLTeacher()
  • 使用UnsafeMutablePointer創(chuàng)建指針，并通過指針訪問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)去訪問，否則取出結果是有問題

image

  • 可以通過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字節(jié)大小，此時獲取的結果是有問題的，由于這里知道具體的類型，所以只需要標識指針前進 幾步即可，即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內存

定義如下代碼

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

class CJLTeacher{
    var age = 18
}

var t = CJLTeacher()

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

  • 1、獲取實例變量的內存地址
  • 2、綁定到結構體內存,返回值是UnsafeMutablePointer<T>
  • 3、訪問成員變量 pointee.kind 
//將t綁定到結構體內存中
//1、獲取實例變量的內存地址，聲明成了非托管對象
/*
 通過Unmanaged指定內存管理，類似于OC與CF的交互方式（所有權的轉換 __bridge）
 - passUnretained 不增加引用計數，即不需要獲取所有權
 - passRetained 增加引用計數，即需要獲取所有權
 - toOpaque 不透明的指針
 */

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

其運行結果如下，有點類似于CF與OC交互的時的所有權的轉換


image

  • create\copy 需要使用retain

  • 不需要獲取所有權 使用unretain

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

    image

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 
//1、綁定到cjl_swift_class
let metaPtr = heapObject.pointee.kind.bindMemory(to: cjl_swift_class.self, capacity: 1)
//2、訪問
print(metaPtr.pointee)

運行結果如下，其本質原因是因為 metaPtr 和 cjl_swift_class的類結構是一樣的

image

實戰(zhàn)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)
}

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

  • 1、定義實例變量
  • 2、獲取實例變量的地址，并將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))
}

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

  • 如果方法的類型與傳入參數的類型不一致，會報錯


    image.png

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

?著作權歸作者所有,轉載或內容合作請聯(lián)系作者
【社區(qū)內容提示】社區(qū)部分內容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發(fā)布，文章內容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關閱讀更多精彩內容

友情鏈接更多精彩內容