最近在用 Swift 实现一个功能的时候，遇到有一些 API 中需要传递的参数是 UnsafePointer，也就是 C 语言指针在 Swift 中的转译。其用法颇具特色，这里有一篇博文讲的不错，特地转过来记一下，方便以后复习查看。

原文链接 传送门

最近做的事情需要在 Swift 里调用 C 函数，要学的东西很多，经历颇为曲折，遂作此笔记以备忘。

1. 什么是指针？

参考这里： The 5-Minute Guide to C Pointers

或者中文版： C 语言指针 5 分钟教程 – 文章 – 伯乐在线

2. Swift 里的不安全操作

Swift 大部分操作都是安全的， Optional 的引入也是为了安全。大部分情况下编译器会帮我们做静态校验，一个 Int 类型不能被当做一个 String 传参，一个 Optional 类型必须 Unwrapped 之后才能安全使用。

1
2

let arr = []
let test = arr[1]

3. MemoryLayout

C/C++ 里常见的 sizeof() 关键字在 Swift 里面原先也有，以及 sizeofValue , strideof , strideofValue , align 和 alignOf 。在 Swift 3 中，这一堆“函数”被包进了 MemoryLayout 这个 Struct 里面，这里是 当时的提案 。

于是和内存对齐内存占用等相关的信息就都可以通过 MemoryLayout 获取，比如：

1
2
3

MemoryLayout<UInt32>.size // 4
MemoryLayout<UInt32>.alignment // 4
MemoryLayout<UInt32>.stride // 4

UInt32 默认占 4 个字节，内存对齐为 4 字节。

连续内存里多个实例排列时（比如数组），上一个实例开始地址到下一个实例开始地址的距离为 4 个字节。

在我的 64-bit 机器上，Int 类型则和 UInt64 类型一样，占 8 个字节。

内存对齐

为什么需要做内存对齐可以参考这里： Purpose of memory alignment – Stack Overflow

理论上物理内存的单位是一个字节(byte)，我们最小能访问的内存就应该是一个字节。但是实际上为了效率考虑，或者硬件限制，我们访问内存总是字长的倍数，字长由设备来决定，比如某机器 64 位机器以 8 字节为字长，这样设备每次访问内存都会以 8 字节为单位。如果内存里的某个值不在 8 字节的边界上，那么处理器想要获取这个值就得访问两次内存，为了性能考虑通常编译器会对这些值做内存对齐，用空间换时间。

另外 App 能访问的内存地址都不是物理地址，而是通过操作系统访问到的虚拟地址。

比如下面这个 Struct ：

1
2
3
4
5
6
7
8

struct SampleStruct {
 	let number: UInt32
 	let flag: Bool
}
 
MemoryLayout<SampleStruct>.size       // returns 5
MemoryLayout<SampleStruct>.alignment  // returns 4
MemoryLayout<SampleStruct>.stride     // returns 8

UInt32 长度 4， Bool 长度 1,总长其实是 5。但是因为内存对齐的存在，所以整个 Struct 塞进内存里会以 4 字节对齐，结果占用 8 个字节(64位机器)。

Struct 和 Int 一样是值类型 (Value Type)，但如果是引用类型(Reference Type) 比如类 class，就不太一样。

Swift class 在底层实现事实上是一个 Objectivce C Class(根据 mikeash 的 这个视频 Xode 8, Swift 3)，我们创建一个新的 Swift class 实例的时候，会在堆上 (heap) 分配一块比较大的内存，用来保存诸如 type , reference count 之类的信息，在栈上 (stack) 只分配一个指针，指向堆上的这块内存。所以对一个 class 执行 MemoryLayout 效果如下:

1
2
3
4
5
6
7
8

class SampleClass {
 	let number: UInt32
 	let flag: Bool
}
 
MemoryLayout<SampleClass>.size       // returns 8
MemoryLayout<SampleClass>.alignment  // returns 8
MemoryLayout<SampleClass>.stride     // returns 8

4. Swift Pointer

Swift 一共有 8 种指针类型。基础是不可变指针 UnsafePointer ，对应的会有可变指针 UnsafeMutablePointer 。另外还有可以塞数组的 Buffer 指针和完全不知道是什么内容的 Raw 指针，也即没有指定泛型。

5. 特殊指针

上面提到的八种指针都比较常见，比如 const int * 对应 Swift UnsafePointer<Int32> 。那如果有些比较复杂的需求上述指针无法满足的怎么办呢？

OpaquePointer

如果一个 C 指针类型无法在 Swift 中找到对应的类型，则可以用这个指针来表达，比如一个类型为 C Struct 的指针。

1
2

init?(bitPattern: Int)
    // Creates an OpaquePointer from a given address in memory.

1
2
3
4
5
6

// 把 self 用 OpaquePointer 指针表达
let pointer = UnsafeMutableRawPointer(Unmanaged.passUnretained(self).toOpaque())
 
// 传给 C 函数... 
// 在 C 函数的回调里面取会这个指针
let someObj = Unmanaged<ObjectClass>.fromOpaque(context!).takeUnretainedValue()

6. 小结

指针非常强大，在 C/C++/ObjC 语言中也是使用非常广泛的工具。但是同时直接操作内存也给程序带来非常高的风险。项目简单的时候问题不大，一旦复杂起来问题就很容易被淹没在茫茫代码里。

想要在使用过程中不犯错就必须先理解这些不安全的操作都做了什么，必须理解指针，理解内存，理解这些操作在 C/C++/Swift 里的差别。@mikeash 的演讲 Exploring Swift Memory Layout 讲得非常好，值得一看。

7. 参考资料

• Swift 中的指针使用
• Swift 皇冠上的明珠：不安全的 Swift 和指针类型
• The 5-Minute Guide to C Pointers
• Unsafe Swift: Using Pointers And Interacting With C
• Exploring Swift Memory Layout
• Swift 对象内存模型探究（一） – iOS – 掘金
• Using Imported C Functions in Swift | Apple Developer Documentation