Swift进阶05:指针

Swift中的指针分为两类

• typed pointer 指定数据类型指针，即 UnsafePointer<T>, 其中T表示泛型
• raw pointer 未指定数据类型指针（原生指针），即 UnsafeRawPointer

swift与OC指针对比如下：

Swift	Object-C	说明
unsafePointer<T>	const T *	指针及所指向的内容都不可变
unsafeMutablePointer<T>	T *	指针及其所指向的内存内容均可变
unsafeRawPointer	const void *	指针指向未知类型
unsafeMutableRawPointer	void *	指针指向未知类型

原生指针

原生指针：是指未指定数据类型的指针，有以下说明

• 对于指针的内存管理是需要手动管理的
• 指针在使用完需要手动释放

原生指针的使用如下

// 1、分配32字节的内存空间大小, 指定对齐方式是8字节对齐
let p = UnsafeMutableRawPointer.allocate(byteCount: 32, alignment: 8)
// 2、advanced代表当前 p 前进的步长，对于 RawPointer 来说，我们需要移动的是当前存储值得内存大小即，MemoryLayout.stride
// 3、storeBytes: 这里就是存储我们当前的数据，这里需要指定我们当前数据的类型
for i in 0..<4 {
    p.advanced(by: i * 8).storeBytes(of: i + 1, as: Int.self)
}

// 4、load顾明思义是加载，fromBytesOffet：是相对于我们当前 p 的首地址的偏移
for i in 0..<4 {
    let value = p.load(fromByteOffset: i * 8, as: Int.self)
    print("index\(i),value:\(value)")
}
// 5、指针在使用完需要 手动释放
p.deallocate()

运行结果如下：

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

var age = 10

//1、通过Swift提供的简写的API，这里注意当前尾随闭包的写法
let p = withUnsafePointer(to: &age){ $0 }
print(p.pointee)

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

let p1 = withUnsafePointer(to: &age) { ptr in
    return ptr
}

image

访问属性

可以通过指针的pointee属性访问变量值，如下所示

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

//--打印结果--
10

如何改变age变量值

改变变量值的方式有两种，一种是间接修改，一种是直接修改

• 间接修改：需要在闭包中直接通过 ptr.pointee修改并返回。类似于char *p = “teacher” 中的 *p，因为访问teacher通过 *p

var age = 10
age = withUnsafePointer(to: &age) { ptr in
    return ptr.pointee + 12
}
print(age)

• 直接修改-方式1：通过withUnsafeMutablePointer方法

var age = 10
withUnsafeMutablePointer(to: &age) { ptr in
    ptr.pointee += 11
}
print(age)

• 直接修改-方式2：通过allocate创建UnsafeMutablePointer，需要注意的是
  • initialize 与 deinitialize是成对的
  • deinitialize中的count与申请时的capacity需要一致
  • 需要deallocate

//1、capacity:容量大小，当前的大小为 1 * 8字节
let ptr = UnsafeMutablePointer<Int>.allocate(capacity: 1)

//2、初始化当前的UnsafeMutablePointer<Int> 指针
ptr.initialize(to: age)
ptr.pointee += 12
print(ptr.pointee)
//3、下面两个成对调用，管理内存
ptr.deinitialize(count: 1)
ptr.deallocate()

指针实例应用

实战1：访问结构体实例对象

定义一个结构体

struct HTTeacher {
    var name = "teacher"
    var age = 18
}
print(MemoryLayout<HTTeacher>.size)
print(MemoryLayout<HTTeacher>.stride)

• 使用 UnsafeMutablePointer创建指针，并通过指针访问 HTTeacher实例对象，有以下三种方式：
  • 方式一：下标访问
  • 方式二：内存平移
  • 方式三：successor()

//分配两个HTTeacher大小的空间
let p = UnsafeMutablePointer<HTTeacher>.allocate(capacity: 2)
//初始化第一个空间
p.initialize(to: HTTeacher())
//移动，初始化第2个空间
p.advanced(by: 1).initialize(to: HTTeacher(name: "wang", age: 30))

//访问方式一
print(p[0])
print(p[1])

//访问方式二
print(p.pointee)
print((p + 1).pointee)

//访问方式三
print(p.pointee)
print((p.successor()).pointee)

//访问方式四
print(p.pointee)
print(p.advanced(by: 1).pointee)

//必须和分配是一致的
p.deinitialize(count: 2)
//释放
p.deallocate()

• 同样，初始化时也可以通过 p + 1、p.successor()或者 p.advanced(by: 1)

原生指针与typed pointer 对比

• 这里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)
}

• 这里的p由于知道存储的具体类型（HTTeacher），所以只需要标识指针前进 几步即可，即advanced(by: 1)

let p = UnsafeMutablePointer<HTTeacher>.allocate(capacity: 2)
//初始化第一个空间
p.initialize(to: HTTeacher())
//移动，初始化第2个空间
p.advanced(by: 1).initialize(to: HTTeacher(name: "wang", age: 30))

实战2：实例对象绑定到struct内存

定义如下代码

struct HeapObject {
    var metadata: UnsafeRawPointer
    var strongref: UInt32
    var unownedRef: UInt32
    var age: Int
}

class HTTeacher {
    var age = 18
}

var t = HTTeacher()

类的实例对象在底层是结构体

demo1：类的实例对象如何绑定到 结构体内存中？

• 1、获取实例变量的内存地址
• 2、绑定到结构体内存，返回值是UnsafeMutablePointer<T>
• 3、访问成员变量 pointee.metadata

//将t绑定到结构体内存中
//1、获取实例变量的内存地址，声明成了非托管对象，返回值是 UnsafeMutableRawPointer
/*
 通过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)
print(heapObject.pointee.metadata)
print(heapObject.pointee.strongref)
print(heapObject.pointee.unownedRef)
print(heapObject.pointee.age)

其运行结果如下，有点类似于CF与OC交互时的所有权的转换

image

• create\copy 需要使用retain
• 不需要获取所有权 使用unretain
• metadata的类型是 UnsafeRawPointer，对应的是类的地址（底层也是 结构体）

demo2：绑定到类结构

将swift中的类结构定义成一个结构体

struct ht_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
}

• 将 metadata绑定到ht_swift_class

// 绑定到 ht_swift_class
let metadataPtr = heapObject.pointee.metadata.bindMemory(to: ht_swift_class.self, capacity: 1)
print(metadataPtr.pointee)

运行结果如下，其本质原因是因为 metadataPtr 和 ht_swift_class的类结构是一样的

image

实战3：元组指针类型转换

• 如果将元组传给 函数testPointer，使用方式如下

var tul = (10, 20)

//UnsafePointer<T>
func testPointer(_ p : UnsafePointer<Int>){
    print(p)
    print(p.pointee)
}

withUnsafePointer(to: &tul) { (tulPtr: UnsafePointer<(Int, Int)>) in
    //不能使用bindMemory，因为已经绑定到具体的内存中了
    //使用assumingMemoryBound，假定内存绑定，目的是告诉编译器ptr已经绑定过Int类型了，不需要再检查memory绑定
    testPointer(UnsafeRawPointer(tulPtr).assumingMemoryBound(to: Int.self))
}

• assumingMemoryBound，假定内存绑定，目的是告诉编译器ptr已经绑定过Int类型了，不需要再检查memory绑定

实战4：如何获取结构体的属性的指针

• 1、定义实例变量
• 2、获取实例变量的地址，并将unownedRef的属性值传递给函数

代码如下：

struct HeapObject {
    var strongref = 10
    var unownedRef = 20
}

var t = HeapObject()
withUnsafePointer(to: &t) { (ptr: UnsafePointer<HeapObject>)  in
    // 1、ptr.advanced(by: <#T##Int#>)？
    let unownedRefPtr = UnsafeRawPointer(ptr).advanced(by: MemoryLayout<HeapObject>.offset(of: \HeapObject.unownedRef)!)

    //2、是不是通过原生指针 + 偏移量
    let unownedRefPtr2 = UnsafeRawPointer(ptr) + MemoryLayout<HeapObject>.offset(of: \HeapObject.unownedRef)!

    testPointer(unownedRefPtr.assumingMemoryBound(to: Int.self))
}

func testPointer(_ p: UnsafePointer<Int>){
    print(p)
    print(p.pointee)
}

实战5：通过 withMemoryRebound 临时绑定内存类型

• 如果方法的类型与传入参数的类型不一致，会报错

image

解决办法：通过withMemoryRebound临时绑定内存类型

var age = 10

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

let p = withUnsafePointer(to: &age) { $0 }

p.withMemoryRebound(to: Int64.self, capacity: 1) { ptr in
    testPointer(ptr)
}

总结

• 指针类型分两种
  • typed pointer 指定数据类型指针，即 UnsafePointer<T> + unsafeMutablePointer<T>
  • raw pointer 未指定数据类型的指针（原生指针） ，即UnsafeRawPointer + unsafeMutableRawPointer
• withMemoryRebound: 临时更改内存绑定类型
• bindMemory(to: Capacity:): 更改内存绑定的类型，如果之前没有绑定，那么就是首次绑定，如果绑定过了，会被重新绑定为该类型
• assumingMemoryBound假定内存绑定，这里就是告诉编译器：我的类型就是这个，你不要检查我了,其实际类型还是原来的类型