前言

本篇文章主要讲解一下Swift中的指针，以及相关的应用场景，指针也是面试官经常问到的知识点，希望大家能够掌握。

一、指针类别

Swift中的指针分为两类

1. typed pointer： 指定数据类型指针，即UnsafePointer<T>，其中T表示泛型
2. raw pointer： 未指定数据类型的指针（原生指针） ，即UnsafeRawPointer

与OC中的指针的对比👇

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<T, Result>(to value: T, _ body: (Swift.UnsafePointer<T>) throws -> Result) rethrows -> Result {}

第二个参数传入的是闭包表达式，然后通过rethrows重新抛出Result（即闭包表达式产生的结果）。既然是闭包，那么上面的例子，我们可以简写👇

withUnsafePointer(to: &age){print($0)}

因为withUnsafePointer方法中的闭包属于单一表达式，因此可以省略参数、返回值，直接使用$0，$0等价于ptr，表示第一个参数，$1表示第二个参数，以此类推。

再看看p的类型👇

类型是UnsafePointer<Int>。

如何访问指针指向的值

我们可以通过指针的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种方式👇

1. 通过withUnsafeMutablePointer方法👇

var age = 18
withUnsafeMutablePointer(to: &age) { ptr in
    ptr.pointee += 12
}

2. 通过allocate创建UnsafeMutablePointer👇

var age = 18
//分配容量大小，为8字节
let ptr = UnsafeMutablePointer<Int>.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点👇

1. 对于指针的内存管理是需要手动管理的
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<LGTeacher>.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<LGTeacher>.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<LGTeacher>.stride)不行，但是advanced(by: 1)却可以呢？

1. advanced(by: MemoryLayout<LGTeacher>.stride) 的移动步长是类LGTeacher实例的大小 -->32 = 16(metadata8 + refcount8) + 16(age8+height8)，而advanced(by: 1)是移动步长为1。
2. 关键在于这句代码-->let ptr = UnsafeMutablePointer<LGTeacher>.allocate(capacity: 2)，此时我们是知道ptr的具体类型的，就是指向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<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)

运行👇

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

上面示例是将元组tul的指针类型 UnsafePointer<(Int, Int)>)转换成了UnsafePointer<Int>。

也可以直接告诉编译器转换成具体的类型👇

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

通过withUnsafePointer将t绑定到结构体HeapObject内存中，然后通过 MemoryLayout<HeapObject>.offset()内存平移获取结构体成员变量strongRef，最后通过assumingMemoryBound进行内存的绑定。

注意:assumingMemoryBound假定内存绑定，这里就是告诉编译器：我的类型就是这个，你不要检查我了,其实际类型还是原来的类型。

运行👇

2.5 临时绑定内存类型

先看以下示例代码👇

var age = 10

func testPointer(_ p: UnsafePointer<Int64>){
   print(p)
}

withUnsafePointer(to: &age) { (ptr: UnsafePointer<Int>) in
    testPointer(ptr)
}

会报错：指针类型不一致！

解决方案：通过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)
}

总结

本篇文章主要讲解了Swift中的2大指针类型：typed pointer和raw pointer，然后讲解了指针的几个常见的应用场景，包含更改内存绑定的类型，假定内存绑定和临时更改内存绑定类型。