Swift 指针底层探索分析

这篇文章主要为大家介绍了Swift 指针底层探索分析，主要包括指针的基本使用，以及指针的内存绑定进行详细分析，希望能够有所帮助，祝大家多多进步，早日升职加薪

概要

主要内容：

指针的认识

指针的常见绑定

1. 指针的认识

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

区别：

1.1 指定类型指针

代码：

运行结果：

说明：

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

1.2 未指定类型指针

代码：

 @inlinable public func withUnsafePointer(to value: inout T, _ body: (UnsafePointer) throws -> Result) rethrows -> Result  var age = 10 let p = withUnsafePointer(to: &age) { $0 } print(p)  withUnsafePointer(to: &age){print($0)}  //其中p1的类型是 UnsafePointer 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.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.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 /* - 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 func testPointer(_ p : UnsafePointer){ 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){ print(p) } //实例化 var  t = HeapObject() //获取结构体属性的指针传入函数 withUnsafePointer(to: &t) { (ptr: UnsafePointer) in //1. 获取变量 let strongRef = UnsafeRawPointer(ptr) + MemoryLayout.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){ print(p) } let ptr = withUnsafePointer(to: &age) {$0} ptr.withMemoryRebound(to: Int64.self, capacity: 1) { (ptr: UnsafePointer)  in testPointer(ptr) }

说明：