http://www.swiftyper.com/2017/01/15/unsafe-swift/
默认情况下,Swift 是内存安全的,这意味着它禁止我们直接操作内存,并且确保所有的变量在使用前都已经被正确地初始化了。但是,Swift 也提供了我们使用指针直接操作内存的方法,直接操作内存是很危险的行为,很容易就出现错误,因此官方将直接操作内存称为 “unsafe 特性”。
一旦我们开始直接操作内存,一切就得靠我们自己了,因为在这种情况下编译能给我们提供的帮助实在不多。正常情况下,我们在与 C 进行交互,或者我们需要挖掘 Swift 内部实现原理的时候会需要使用到这个特性。
Memory Layout
Swift 提供了MemoryLayout
来检测特定类型的大小以及内存对齐大小:
|
@H_404_59@
MemoryLayout<Type>
是一个用于在编译时计算出特定类型(Type)的 size,alignment 以及 stride 的泛型类型。返回的数值以字节为单位。例如Int16
类型的大小为 2 个字节,内存对齐为 2 个字节以及当我们需要连续排列多个Int16
类型时,每一个Int16
所需要占用的大小(stride)为 2 个字节。所有基本类型的 stride 都与 size 是一致的。
接下来,看看结构体类型的 MemoryLayout:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
@H_404_59@
空结构体的大小为 0,内存对齐为 1, 表明它可以存在于任何一个内存地址上。有趣的是 stride 为 1,这是因为尽管结构为空,但是当我们使用它创建一个实例的时候,它也必须要有一个唯一的地址。
对于SampleStruct
,它所占的大小为 5,但是 stride 为 8。这是因为编译需要为其填充空白的边界,使其符合它的 4 字节内存边界对齐。
再来看看类:
class EmptyClass {}
EmptyClass>.size
// returns 8 (on 64-bit)
EmptyClass>.alignment
EmptyClass>.
stride
// returns 8 (on 64-bit)
SampleClass {
Int64 =
0
Bool =
false
}
SampleClass>.size
SampleClass>.aligment
SampleClass>.
// returns 8 (on 64-bit)
|
由于类都是引用类型,所以它所有的大小都是 8 字节。
关于 MemoryLayout 的更多详细信息可以参考Mike Ash 的演讲。
指针
一个指针就是对一个内存地址的封装。在 Swift 当中直接操作指针的类型都有一个 “unsafe” 前缀,所以它的指针类型称为UnsafePointer
。这个前缀似乎看起来很令人恼火,不过这是 Swift 在提醒你,你现在正在跨越雷池,编译器不会对这种操作进行检查,你需要对自己的代码承担全部的责任。
Swift 中包含了一打类型的指针类型,每个类型都有它们的作用和目的,使用适当的指针类型可以防止错误的发生并且更清晰地表达开发者的意图,防止未定义行为的产生。
Swift 的指针类型使用了很清晰的命名,我们可以通过名字知道这是一个什么类型的指针。可变或者不可变,原生(raw)或者有类型的,是否是缓冲(buffer)类型,这三种特性总共组合出了 8 种指针类型。
接下来的几个小节会详细介绍这几种指针类型。
使用原生(Raw)指针
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
@H_404_59@
在这个代码段中,我们使用了 Unsafe Swift 指针去存储和读取两个整型数值。接下来是对这段代码的解释:
- 声明了接下来都会用到的几个常量:
count
表示了我们要存储的整数的个数stride
表示了 Int 类型的 stridealignment
表示了 Int 类型的内存对齐byteCount
表示占用的全部字节数
- 使用
do
来增加一个作用域,让我们可以在接下的示例中复用作用域中的变量名 - 使用
UnsafeMutableRawPointer.allocate
方法来分配所需的字节数。我们使用了 UnsafeMutableRawPointer,它的名字表明这个指针可以用来读取和存储(改变)原生的字节。 - 使用 defer 来保证内存得到正确地释放。操作指针的时候,所有内存都需要我们手动进行管理。
storeBytes
和load
方法用于存储和读取字节。第二个整型数值的地址通过对 pointer 的地址前进 stride 来得到。因为指针类型是Strideable
的,我们也可以直接使用指针算术运算(pointer+stride).storeBytes(of: 6,as: Int.self)
。UnsafeRawBufferPointer
类型以一系列字节的形式来读取内存。这意味着我们可以这些字节进行迭代,对其使用下标,或者使用filter
,map
以及reduce
这些很酷的方法。缓冲类型指针使用了原生指针进行初始化。
使用类型指针
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
@H_404_59@
注意到以下几点不同:
- 我们使用了 UnsafeMutablePointer.allocate 进行内存的分配。指定的泛型参数让 Swift 知道我们将会使用这个指针来存储和读取 Int 类型的值。
- 在使用类型指针前需要对其进行初始化,并在使用后销毁。这两个功能分别是使用 initialize 和 deinitialize 方法。
- 类型指针提供了
pointee
属性,它可以以类型安全的方式读取和存储值。 - 当需要指针前进的时候,我们只需要指定想要前进的个数。类型指针会自动根据它所指向的数值类型来计算 stride 值。同样的,我们可以直接对指针进行算术运算
(pointer + 1).pointee = 6
。 - 有类型的缓冲型指针也会直接操作数值,而非字节
将原生指针转换为类型指针
类型指针并不总是使用初始化得到的,它们可以从原生指针中转化而来。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
@H_404_59@
这段代码与上一段类似,除了它先创建了原生指针。我们通过将内存绑定(binding)到指定的类型上来创建类型指针。通过对内存的绑定,我们可以通过类型安全的方法来访问它。将我们手动创建类型指针的时候,系统其实自动帮我们进行了内存绑定。
获取一个实例的字节
很多时候我们需要从一个现存的实例里获取它的字节。这时可以使用withUnsafeBytes(of:)
方法。
1
2
3
4
5
6
7
8
9
10
11
|
@H_404_59@
这段代码会打印出SampleStruct
实例的原生字节。withUnsafeBytes(of:)
方法可以获取到UnsafeRawBufferPointer
并传入闭包中供我们使用。
withUnsafeBytes
同样适合用Array
和Data
的实例。
使用 Swift 操作指针的三大原则
当我们使用 Swift 操作指针的时候必须加倍小心,防止写出未定义行为的代码。下面是几个坏代码的示例。
不要从 withUnsafeBytes 中返回指针
1
2
3
4
5
6
7
8
9
10
11
12
|
@H_404_59@
绝对不要让指针逃出withUnsafeBytes(of:)
的作用域范围。这样的代码会成为定时炸弹,你永远不知道它什么时候可以用,而什么时候会崩溃。
一次只绑定一种类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
@H_404_59@
绝对不要让一个内存同时绑定两个不同的类型。如果你需要临时这么做,可以使用withMemoryRebound(to:capacity:)
来对内存进行重新绑定。并且,这条规则也表明了不要将一个基本类型(如 Int)重新绑定到一个自定义类型(如 class)上。不要做这种傻事。
不要操作超出范围的内存
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
// Rule #3... wait |
这是最糟糕的一种错误了,请再三检查你的代码,保证不要有这种情况出现。切记。
示例:随机数生成
随机数在很多地方都有重要的作用,从游戏到机器学习。macOS 提供了arc4random
方法用于随机数生成。不幸的是,这个方法无法在 Linux 上使用。并且,arc4random
方法只提供了UInt32
类型的随机数。事实上,/dev/urandom
这个设备文件中就提供了无限的随机数。
这一小节中,我们将使用指针读取这个文件,并产生完全类型安全的随机数。
创建一个新 Playground,命名为RandomNumbers,并确保选择了macOS
平台。
import Foundation
enum RandomSource {
static
let file = fopen(
"/dev/urandom","r")!
let queue =
DispatchQueue(label:
"random")
static
func get(count: Int) -> [
Int8] {
let capacity =
count +
1
// fgets adds null termination
var data =
Int8>.allocate(capacity: capacity)
defer {
data.deallocate(capacity: capacity)
}
queue.sync {
fgets(data,Int32(capacity),file)
}
return
Array(
UnsafeMutableBufferPointer(start: data,47)">count))
}
}
|
为了确保整个系统中只存在一个file
变量,我们对其使用了static
修饰符。系统会在我们的进程结束时关闭文件。因为我们有可能在多个线程中同时获取随机数,所以需要使用一个串行的 GCD 队列来进行保护。
get
函数是所有功能完成的地方。首先,我们根据传入的大小分配了必要的内存,注意这里需要 +1 是因为fets
函数总是以\0
结束。接下来,我们就使用fgets
函数从文件中读取数据,确保我们在串行队列中进行读取操作。最后,我们先将数据封装为一个UnsafeMutableBufferPointer
,并将其转化为一个数组。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
@H_404_59@
这里我们为 Integer 协议添加了一个静态属性,并为其提供了默认实现。我们首先获取了随机数,随后我们将获得字节数组重新绑定为所需要的类型,然后返回它的值。简单!
就这样,我们使用 unsafe Swift 实现了一个类型安全的随机器生成方法。
小结
在日常开发中,我们并不会接触到很多直接操作内存的情境。但是掌握它的操作,能让我们在碰到类似代码里更加从容。