Swift 指针底层探索分析

概要

主要内容:

指针的认识

指针的常见绑定

1. 指针的认识

指针分为两类,指定数据类型和未指定数据类型

区别:

1.1 指定类型指针

代码:

运行结果:

说明:

  • 指针的内存需要自己管理,需要手动开辟空间和释放空间
  • 存储数据时,需要移动一定的字节大小
  • 移动通过advanced实现
  • 存储数据通过storeBytes实现
  • 取出数据通过load实现

1.2 未指定类型指针

代码:

<!--定义-->
@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的定义,我们可以看到闭包中返回的结果就是这个函数返回的结果
  • 因此我们在使用这个指针时,就可以通过闭包返回数据来决定拿到的结果
  • 所以可以看到我们可以有两种方式,1)直接返回指针;2)返回具体的数据

访问属性:

直接修改:

直接在闭包中计算后将结果返回给属性

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

间接修改:

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()

说明:

  • 返回指针,指针拿到pointee来进行修改

1.3 访问结构体实例对象

结构体:

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

指针处理:

//分配两个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()

说明:

  • 直接通过下标来获取
  • 通过指针偏移来获取
  • 通过successor()偏移一步来获取,它可以通用在指定指针类型和未指定指针类型

2. 指针的常见绑定

2.1 指针与内存空间的绑定(指向)(bindMemory)

将指针指向某个内存空间,也就是绑定到这个内存空间上

定义:

struct HeapObject {
    var kind: Int
    var strongRef: UInt32
    var unownedRef: UInt32
}
class CJLTeacher{
    var age = 18
}
var t = CJLTeacher()

绑定:

//将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)

说明:

  • 首先创建一个指针,指针指向CJLTeacher
  • 通过bindMemeory将指针绑定到结构体HeapObject中
  • 接下来就可以通过这个指针来访问内存数据了

2.2 元组指针类型转换(假定内存绑定assumingMemoryBound)

元组和指针指向内存的数据类型不一样,就需要使用假定内存绑定

代码:

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))
}

说明:

  • testPointe需要传入的是一个泛型为Int的指针
  • 我们此时想要传入一个元组,元组类型为(Int, Int),与Int类型不一样
  • 因此无法通过memoryBind来直接指向Int内存
  • 所以就需要通过assumingMemoryBound(to: Int.self)来指向
  • 这是因为假定内存绑定是假绑定,不需要进行严格的类型检查

举例:获取结构体的属性的指针

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
    //1. 获取变量
    let strongRef = UnsafeRawPointer(ptr) + MemoryLayout<HeapObject>.offset(of: \HeapObject.strongRef)!
    //2. 传递strongRef属性的值
    testPointer(strongRef.assumingMemoryBound(to: Int.self))
}

说明:

  • 通过地址偏移拿到结构体中的strngRef变量
  • 之后也是通过假定绑定将其转换为一个指针(从Uint32到Int)

2.3 通过 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)
}

说明:

  • 此处可以看到ptr的指针泛型为Int,而testPointer的参数指针泛型为Int64,所以并不能直接传递
  • 而这个指针我们只是作为参数传递,所以就可以临时绑定一下
  • 实现方式就是ptr.withMemoryRebound(to: Int64.self, capacity: 1)
  • 在出了这个作用域后,ptr仍然是Int类型

3、总结

  • 指针类型分两种
  • typed pointer 指定数据类型指针,即 UnsafePointer< T > + unsafeMutablePointer
  • raw pointer 未指定数据类型的指针(原生指针) ,即UnsafeRawPointer + unsafeMutableRawPointer

指针的内存管理需要手动管理

假定内存绑定和内存绑定的区别

需要注意对于指针类型指针,可以通过指针偏移来偏移内存大小,而对于未指定类型的指针,只能通过内存偏移来偏移内存大小

将一个指针绑定到内存中,其实就是指向到这个内存空间

三种绑定的区别

  • 绑定:bindMemory(to: Capacity:): 更改内存绑定的类型,如果之前没有绑定,那么就是首次绑定,如果绑定过了,会被重新绑定为该类型
  • 假定绑定:assumingMemoryBound假定内存绑定,这里就是告诉编译器:我的类型就是这个,你不要检查我了,其实际类型还是原来的类型
  • 临时绑定:withMemoryRebound: 临时更改内存绑定类型
作者:文乙

%s 个评论

要回复文章请先登录注册