前言
本篇文章主要讲解一下Swift中的指针，以及相关的应用场景，指针也是面试官经常问到的知识点，希望大家能够掌握。
一、指针类别
Swift中的指针分为两类
-
typed pointer： 指定数据类型指针，即UnsafePointer，其中T表示泛型 -
raw pointer： 未指定数据类型的指针（原生指针） ，即UnsafeRawPointer
与OC中的指针的对比
| OC | Swift | 释义 |
|---|---|---|
| const T * | unsafePointer |
指针及所指向的内容都不可变 |
| T * | unsafeMutablePointer | 指针及所指向的内容都可变 |
| const void * | unsafeRawPointer | 无类型指针，指向的值必须是常量 |
| void * | unsafeMutableRawPointer | 无类型指针，也叫通用指针 |
1.1 type pointer
我们获取基本数据类型的地址可通过withUnsafePointer(to:)方法获取，例如
var age = 18
let p = withUnsafePointer(to: &age) { ptr in
return ptr }
print(p)
在Swift源码中搜索withUnsafePointer(to:)，查看其定义
我们以arm64为例，其定义
@inlinable public func withUnsafePointer(to value: T, _ body: (Swift.UnsafePointer) throws -> Result) rethrows -> Result {}
第二个参数传入的是闭包表达式，然后通过rethrows重新抛出Result（即闭包表达式产生的结果）。既然是闭包，那么上面的例子，我们可以简写
withUnsafePointer(to: &age){print($0)}
因为withUnsafePointer方法中的闭包属于单一表达式，因此可以省略参数、返回值，直接使用$0，$0等价于ptr，表示第一个参数，$1表示第二个参数，以此类推。
再看看p的类型
类型是UnsafePointer。
如何访问指针指向的值
我们可以通过指针的pointee属性访问变量值
var age = 18
let p = withUnsafePointer(to: &age) { ptr in
return ptr }
print(p.pointee)
如何修改指针指向的值
有2种方式，间接修改 & 直接修改。
- 间接修改
var age = 18
age = withUnsafePointer(to: &age) { ptr in
//返回Int整型值
return ptr.pointee + 12
}
print(age)
在闭包中直接通过ptr.pointee修改并返回。
- 直接修改
直接修改也分2种方式
- 通过
withUnsafeMutablePointer方法
var age = 18
withUnsafeMutablePointer(to: &age) { ptr in
ptr.pointee += 12
}
- 通过
allocate创建UnsafeMutablePointer
var age = 18
//分配容量大小，为8字节
let ptr = UnsafeMutablePointer.allocate(capacity: 1)
//初始化
ptr.initialize(to: age)
ptr.deinitialize(count: 1)
ptr.pointee += 12
print(ptr.pointee)
//释放
ptr.deallocate()
通过
allocate创建UnsafeMutablePointer，需要注意以下几点
initialize与deinitialize需成对使用deinitialize中的count与申请时的capacity需要一致- 使用完后必须
deallocate
1.2 raw pointer
raw pointer也叫做原生指针，就是指未指定数据类型的指针。
使用
原生指针需要注意2点
- 对于指针的内存管理是需要
手动管理的- 指针在使用完需要
手动释放
例如
//定义一个未知类型的指针：本质是分配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)")
}
//使用完需要手动释放
p.deallocate()
运行
上图可见，读取出来的值不对，原因是存值for循环时，p中每8个字节存储的是i+1，但是却没有指定i+1这个值占的内存大小，也就是没有指定值的内存大小。
解决：通过advanced(by:)指定存储时的步长。
for i in 0..<4 {
//指定当前移动的步数，即i * 8
p.advanced(by: i * 8).storeBytes(of: i + 1, as: Int.self)
}
二、相关应用场景
2.1 访问结构体对象
我们先定义一个结构体
struct LGTeacher {
var age = 18
var height = 1.85
}
var t = LGTeacher()
然后我们使用UnsafeMutablePointer创建指针，然后访问结构体对象t，代码
// 分配2个LGTeacher大小的空间
let ptr = UnsafeMutablePointer.allocate(capacity: 2)
// 初始化第一个空间
ptr.initialize(to: LGTeacher())
// 移动，初始化第2个空间
ptr.successor().initialize(to: LGTeacher(age: 20, height: 1.75))
//访问方式一 下标访问
print(ptr[0])
print(ptr[1])
//访问方式二 内存平移
print(ptr.pointee)
print((ptr+1).pointee)
//访问方式三 successor()
print(ptr.pointee)
//successor 往前移动
print(ptr.successor().pointee)
//必须和分配是一致的
ptr.deinitialize(count: 2)
//释放
ptr.deallocate()
有3种方式访问 下标 + 内存平移 + successor()。运行
那能否通过advanced(by: MemoryLayout)的方式来访问呢？改一下初始化第二个LGPerson的代码
ptr.advanced(by: MemoryLayout.stride).initialize(to: LGTeacher(age: 20, height: 1.80))
运行看看
第二个LGPerson的数据出问题了，看来通过advanced(by: MemoryLayout)指定步长的方式是错误的。正确的方式可以有以下几种
// 内存平移
(ptr + 1).initialize(to: CJLTeacher(age: 20, height: 1.80))
// successor()
ptr.successor().initialize(to: CJLTeacher(age: 20, height: 1.80))
// advanced(by: 1)
ptr.advanced(by: 1).initialize(to: CJLTeacher(age: 20, height: 1.80))
那为什么advanced(by: MemoryLayout不行，但是advanced(by: 1)却可以呢？
-
advanced(by: MemoryLayout的移动步长是类LGTeacher实例的大小 -->32 =.stride) 16(metadata8 + refcount8) + 16(age8+height8)，而advanced(by: 1)是移动步长为1。 - 关键在于这句代码-->
let ptr = UnsafeMutablePointer，此时我们是知道ptr的具体类型的，就是.allocate(capacity: 2) 指向LGTeacher的指针
所以在确定指针的类型后，通过步长的移动+1，就表示移动了那个类的实例大小空间+1。
2.2 实例对象绑定到struct的内存
示例代码
struct HeapObject {
var kind: Int
var strongRef: UInt32
var unownedRef: UInt32
}
class LGTeacher{
var age = 18
}
var t = LGTeacher()
我们将 LGTeacher实例对象t绑定到结构体HeapObject中，代码
//将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)
运行
再将kind的类型改成UnsafeRawPointer
struct HeapObject {
var kind: UnsafeRawPointer
var strongRef: UInt32
var unownedRef: UInt32
}
运行
kind的输出就是地址了。
接着我们换一个结构体 --> Swift类Class对应的底层的结构体
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 flinstanceAlignMask: UInt16
var reserved: UInt16
var classSize: UInt32
var classAddressOffset: UInt32
var description: UnsafeRawPointer
}
因为kind也是一个指针，我们再将kind绑定到lg_swift_class结构体，代码
let metaPtr = heapObject.pointee.kind.bindMemory(to: lg_swift_class.self, capacity: 1)
print(metaPtr.pointee)
运行
2.3 元组指针类型转换
示例
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))
}
上面示例是将元组tul的指针类型 UnsafePointer<(Int, Int)>)转换成了UnsafePointer。
也可以直接告诉编译器转换成具体的类型
func testPointer(_ p: UnsafeRawPointer){
p.assumingMemoryBound(to: Int.self)
}
2.4 获取结构体的成员变量的指针
示例
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
//获取变量
let strongRef = UnsafeRawPointer(ptr) + MemoryLayout.offset(of: \HeapObject.strongRef)!
//传递strongRef属性的值
testPointer(strongRef.assumingMemoryBound(to: Int.self))
}
通过withUnsafePointer将t绑定到结构体HeapObject内存中，然后通过 MemoryLayout内存平移获取结构体成员变量strongRef，最后通过assumingMemoryBound进行内存的绑定。
注意:
assumingMemoryBound假定内存绑定，这里就是告诉编译器：我的类型就是这个，你不要检查我了,其实际类型还是原来的类型。
运行
2.5 临时绑定内存类型
先看以下示例代码
var age = 10
func testPointer(_ p: UnsafePointer){
print(p)
}
withUnsafePointer(to: &age) { (ptr: UnsafePointer) in
testPointer(ptr)
}
会报错：指针类型不一致！
解决方案：通过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)
}
总结
本篇文章主要讲解了Swift中的2大指针类型：typed pointer和raw pointer，然后讲解了指针的几个常见的应用场景，包含更改内存绑定的类型，假定内存绑定和临时更改内存绑定类型。