参考文献
Swift结构体指针操作
官方文档
Swift 和 C 不得不说的故事
Swift指针和托管，你看我就够了
Why？
swift中并不推荐对指针直接操作，但毕竟iOS中有的库还是使用C语言构建的，在与C混编的时候，不可避免的要将对象转换为C的指针类型以便传值。比如GCD,CF框架Runloop操作。
各种指针
对应表
下面表中Type为类型占位，可替换为int等等
对于返回值、变量、参数的指针：
| C | Swift | example |
|---|---|---|
| const Type * | UnsafePointer<Type> | const int * 转换为UnsafePointer <Int32> |
| Type * | UnsafeMutablePointer<Type> | int * 转换为UnsafeMutablePointer <Int32> |
对于类对象的指针
| C | Swift |
|---|---|
| Type * const * | UnsafePointer<Type> |
| Type * __strong * | UnsafeMutablePointer<Type> |
| Type ** | AutoreleasingUnsafeMutablePointer<Type> |
对于无符号类型、
| C | Swift |
|---|---|
| const void * | UnsafeRawPointer |
| void * | UnsafeMutableRawPointer |
如果像不完整结构体的这样的c指针的值的类型无法用Swift来表示，则用OpaquePointer来表示
常量指针
定义为 UnsafePointer<Type> 的指针为常量指针，在C中有const修饰。
当函数的参数修饰为 UnsafePointer<Type>的时候，可以接收下面几种类型的值：
- 类型为
UnsafePointer<Type>, UnsafeMutablePointer<Type>, or AutoreleasingUnsafeMutablePointer<Type>或者转换为UnsafePointer<Type>类型的值。 -
String类型的值，如果类型是Int8或UInt8，那字符串会自动转换为UTF8的buffer，然后这个buffer的指针将会传入函数。 - 表达式Type类型的变量、属性、同类型的下标表达（如：a[0]），这样的情况下，将左边起始地址传入函数。
-
[Type]数组类型值，将数组起始地址传入函数。
在调用函数时，必须保证传入的值可用。
例子：
func takesAPointer(_ p: UnsafePointer<Float>) {
// ...
}
var x: Float = 0.0
takesAPointer(&x)
takesAPointer([1.0, 2.0, 3.0])
上面的例子中必须定义时必须指定一个类型，如：Float。可以使用UnsafeRawPointer修饰，则可以传入相同类型的Type。
例子：
func takesARawPointer(_ p: UnsafeRawPointer?) {
// ...
}
var x: Float = 0.0, y: Int = 0
takesARawPointer(&x)
takesARawPointer(&y)
takesARawPointer([1.0, 2.0, 3.0] as [Float])
let intArray = [1, 2, 3]
takesARawPointer(intArray)
可变指针
定义为UnsafeMutablePointer<Type>、UnsafeMutableRawPointer的指针为可变指针，可以接收下面几种类型的值：
- 类型为
UnsafeMutablePointer<Type>类型的值。 - 表达式
Type类型的变量、属性、同类型的下标表达（如：a[0]），这样的情况下，将地址传入函数。 - 表达式
[Type]类型的变量、属性、同类型的下标表达，这样的情况下，将左边起始地址传入函数。
func takesAMutablePointer(_ p: UnsafeMutablePointer<Float>) {
// ...
}
var x: Float = 0.0
var a: [Float] = [1.0, 2.0, 3.0]
takesAMutablePointer(&x)
takesAMutablePointer(&a)
// 不指定具体类型
func takesAMutableRawPointer(_ p: UnsafeMutableRawPointer?) {
// ...
}
var x: Float = 0.0, y: Int = 0
var a: [Float] = [1.0, 2.0, 3.0], b: [Int] = [1, 2, 3]
takesAMutableRawPointer(&x)
takesAMutableRawPointer(&y)
takesAMutableRawPointer(&a)
takesAMutableRawPointer(&b)
Autoreleasing Pointers(自动释放指针)
定义为AutoreleasingUnsafeMutablePointer<Type>，可以接收下面几种类型的值：
-
AutoreleasingUnsafeMutablePointer<Type>的值 - 表达式
Type类型的变量、属性、同类型的下标表达（如：a[0]），这里会按位拷贝到临时缓冲区，缓冲区的值会被加载，retain，分配值。
注意：不能传数组
例子：
func takesAnAutoreleasingPointer(_ p: AutoreleasingUnsafeMutablePointer<NSDate?>) {
// ...
}
var x: NSDate? = nil
takesAnAutoreleasingPointer(&x)
函数指针
在C中有回调函数，当swift要调用C中这类函数时，可以使用函数指针。
swift中可以用@convention 修饰一个闭包，
- @convention(swift) : 表明这个是一个swift的闭包
- @convention(block) ：表明这个是一个兼容oc的block的闭包，可以传入OC的方法。
- @convention(c) : 表明这个是兼容c的函数指针的闭包，可以传入C的方法。
C中的方法int (*)(void) 在swift中就是@convention(c) () -> Int32
在调用C函数需要传入函数指针时，swift可以传入闭包的字面量或者nil，也可以直接传入一个闭包。
例如:
func customCopyDescription(_ p: UnsafeRawPointer?) -> Unmanaged<CFString>? {
// return an Unmanaged<CFString>? value
}
var callbacks = CFArrayCallBacks(
version: 0,
retain: nil,
release: nil,
copyDescription: customCopyDescription,
equal: { (p1, p2) -> DarwinBoolean in
// return Bool value
}
)
var mutableArray = CFArrayCreateMutable(nil, 0, &callbacks)
上面的例子中，retain、release是传入的nil，copyDescription是传入的函数字面量，equal是直接传入的闭包。
Buffer Pointers
buffer指针用于比较底层的内存操作，你可以使用buffer指针做高效的处理和应用程序与服务间的通信。
有下面几种类型的buffer指针
- UnsafeBufferPointer
- UnsafeMutableBufferPointer
- UnsafeRawBufferPointer
- UnsafeMutableRawBufferPointer
UnsafeBufferPointer、 UnsafeMutableBufferPointer，能让你查看或更改一个连续的内存块。
UnsafeRawBufferPointer、UnsafeMutableRawBufferPointer能让你查看或更改一个连续内存块的集合，集合里面每个值对应一个字节的内存。
指针用法
当使用指针实例的时候，可以使用pointee属性获取指针指向内容的值，指针不会自动管理内存或对准担保。你必须自己管理生命周期以避免泄露和未定义的行为。
内存可能有几种状态：未指定类型未初始化、指定类型未初始化、指定类型已初始化。
- 未分配的：没有预留的内存分配给指针
- 已分配的：指针指向一个有效的已分配的内存地址，但是值没有被初始化。
- 已初始化：指针指向已分配和已初始化的内存地址。
指针将根据我们具体的操作在这 3 个状态之间进行转换。
用法示例
未分配的指针用allocate方法分配一定的内存空间。
let uint8Pointer = UnsafeMutablePointer<UInt8>.allocate(capacity: 8)
分配完内存空间的指针用各种init方法来绑定一个值或一系列值。初始化时，必须保证指针是未初始化的。(初始化过的指针可以再次调用初始化方法不会报错，所以使用时需要特别注意。)
uint8Pointer.initialize(to: 20, count: 8)
print(uint8Pointer[0]) // 20
然后修改值
uint8Pointer[0] = 10
print(uint8Pointer[0]) // 10
回到初始化值之前，没有释放指针指向的内存，指针依旧指向之前的值。
uint8Pointer.deinitialize(count: 8)
释放指针指向的内存,据官方文档说，在释放指针内存之前，必须要保证指针是未初始化的，不然会产生问题。
uint8Pointer.deallocate(capacity: 8)
print(uint8Pointer[0]) // 可能是任何值，已经销毁了
其他用法
看个栗子：
struct MyStruct1{
var int1:Int
var int2:Int
}
var s1ptr = UnsafeMutablePointer<MyStruct1>.allocate(capacity: 5)
s1ptr[0] = MyStruct1(int1: 1, int2: 2)
s1ptr[1] = MyStruct1(int1: 1, int2: 2) // 似乎不应该是这样，但是这能够正常工作
s1ptr.deinitialize(count: 5)
s1ptr.deallocate(capacity: 5)
这个栗子中没有使用init方法来初始化指针，但是可以正常工作。不过这样写并不推荐，它不适用指针指向一个类，或某些特定的结构体和枚举的情况。
why？
当你使用上面提及的方式修改内存内容，从内存管理角度来说，有关这种行为背后的原因和发生时有关的。让我们来看一个不需要手动初始化内存的代码片段，倘若我们在没有初始化 UnsafePointer 情况下改变了指针指向的内存，会引发崩溃。
class TestClass{
var aField:Int = 0
}
struct MyStruct2{
var int1:Int
var int2:Int
var tc:TestClass // 这个字段是引用类型
}
var s2ptr = UnsafeMutablePointer<MyStruct2>.allocate(capacity: 5)
s2ptr.initialize(to: MyStruct2(int1: 1, int2: 2, tc: TestClass()), count: 2) // 删除这行初始化代码将引发崩溃
s2ptr[0] = MyStruct2(int1: 1, int2: 2, tc: TestClass())
s2ptr[1] = MyStruct2(int1: 1, int2: 2, tc: TestClass())
s2ptr.deinitialize(count: 5)
s2ptr.deallocate(capacity: 5)
MyStruct2 包含一个引用类型，所以它的生命周期交由 ARC 管理。当我们修改其中一个指向的内存模块值的时候，Swift 运行时将试图释放之前存在的对象，由于这个对象没有被初始化，内存存在垃圾，你的应用将会崩溃。
请牢记这一点，从安全的角度来讲，最受欢迎的初始化手段是使用 initialize 分配完成内存后，直接设置变量的初始值。
转换
可变 不可变
当一个函数需要传入不可变指针时，可变指针可以直接传入。
而当一个函数需要可变指针时，可以使用init(mutating other: UnsafePointer<Pointee>)方法转换
var i: Int8 = 12
func printPointer(p: UnsafePointer<Int8>) {
let muS2ptr = UnsafeMutablePointer<Int8>.init(mutating: p)!
print(muS2ptr.pointee)
}
printPointer(p: &i)
各种类型转换：
var i: Int8 = 12
func printPointer(p: UnsafePointer<Int8>) {
let muS2ptr = UnsafeMutablePointer<Int8>.init(mutating: p)! // UnsafePointer<Int8> -> UnsafeMutablePointer<Int8>
print(muS2ptr.pointee)
var constUnTypePointer = UnsafeRawPointer(p) // UnsafePointer<Int8> - > UnsafeRawPointer
var unTypePointer = UnsafeMutableRawPointer(mutating: constUnTypePointer) // UnsafeRawPointer -> UnsafeMutableRawPointer
var unTypePointer2 = UnsafeMutableRawPointer(muS2ptr) // UnsafeMutablePointer<Int8> -> UnsafeMutableRawPointer
}
指针可以使用load等方法转为对应的类型
func print<T>(address p: UnsafeRawPointer, as type: T.Type) {
let value = p.load(as: type)
print(value)
}
不同类型
下面的例子展示了将Uint8的指针 转换为UInt64类型。
var i: UInt8 = 125
func printPointer(uint8Pointer: UnsafePointer<UInt8>) {
let pointer0 = UnsafeRawPointer(uint8Pointer)
.bindMemory(to: UInt64.self, capacity: 1)
let pointer0Value = pointer0.pointee
print(pointer0Value) // UInt64
let pointer1 = UnsafeRawPointer(uint8Pointer).assumingMemoryBound(to: UInt64.self)
let pointer1Value = pointer1.pointee
print(pointer1Value) // UInt64
let pointer2Value = UnsafeRawPointer(uint8Pointer).load(as: UInt64.self)
print(pointer2Value) // UInt64
let pointer3 = UnsafeMutablePointer(mutating: uint8Pointer).withMemoryRebound(to: UInt64.self, capacity: 1) { return $0 }
print(pointer3.pointee) // UInt64
}
printPointer(uint8Pointer: &i)
对象转换
在调用一些底层库的时候，经常要把Swift对象传入C中，然后将从C中的回调函数中转换成Swift对象。
下面是我自己写的一个例子：
定义的C代码是：
// c的头文件
#include <stdio.h>
typedef struct {
void *info;
const void *(*retain)(const void *info);
}Context;
void abcPrint(Context *info, void (*callback)(void *));
// c 的实现文件
void abcPrint(Context *info, void (*callback)(void *)){
(*callback)(info->info);
printf("abcPrint call");
}
上面的代码context中有个info可以带void *对象， 然后在回调方法中将info对象返回回来。
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view, typically from a nib.
var blockSelf = self
let controllerPoint = withUnsafeMutablePointer(to: &blockSelf) { return $0}
print("\(self)")
var context = Context(info: controllerPoint, retain: nil)
abcPrint(&context) {
let controller1 = $0?.assumingMemoryBound(to: ViewController.self).pointee
print("controller1: \(String(describing: controller1))")
let controller2 = $0?.bindMemory(to: ViewController.self, capacity: 1).pointee
print("controller2: \(String(describing: controller2))")
let controller3 = $0?.load(as: ViewController.self)
print("controller3: \(String(describing: controller3))")
}
}
}
withUnsafeMutablePointer方法可以将Swift对象ViewController转换为UnsafeMutablePointer<ViewController>类型，这样才可以当做参数传入C函数。
C函数的回调函数中，传出来一个UnsafeMutableRawPointer对象的指针，我展示了3种方式，可以将这个指针转换为ViewController对象。
CFRoopLoop使用
相信有的人看到上面的代码，知道我为什么会写这个知识点了。因为我在使用CFRunLoop优化大图加载的时候遇到了这样的一个需求。
当创建CFRunLoopObserverContext时需要传入Swift对象到info属性，在CFRunLoopObserverCreate的回调函数中，会把这个info返回回来使用。这里就需要这样的类型转换。
Unmanaged方式
苹果的一些底层框架返回的对象有的是自动管理内存的（annotated APIs），有的是不自动管理内存。
对于Core Fundation中有@annotated注释的函数来说，返回的是托管对象，无需自己管理内存，可以直接获取到CF对象，并且可以无缝转化(toll free bridging)成Fundation对象，比如NSString和CFString。目前，内存管理注释正在一步步的完善，所以等到未来某一个版本我们就可以完完全全的像使用Fundation一样使用Core Fundation啦。
-
对于尚未注释的函数来说，苹果给出的是使用非托管对象
Unmanaged<T>进行管理的过渡方案。
当我们从CF函数中获取到Unmanaged<T>对象的时候，我们需要调用takeRetainedValue或者takeUnretainedValue获取到对象T。具体使用哪一个方法，苹果提出了Ownership Policy，具体来说就是：- 如果一个函数名中包含
Create或Copy，则调用者获得这个对象的同时也获得对象所有权，返回值Unmanaged需要调用takeRetainedValue()方法获得对象。调用者不再使用对象时候，Swift代码中不需要调用CFRelease函数放弃对象所有权，这是因为Swift仅支持ARC内存管理，这一点和OC略有不同。 - 如果一个函数名中包含Get，则调用者获得这个对象的同时不会获得对象所有权，返回值Unmanaged需要调用takeUnretainedValue()方法获得对象。
- 如果一个函数名中包含
下面是我自己的试验的代码:
func addRunloopOberver1() {
let controllerPoint = Unmanaged<ViewController>.passUnretained(self).toOpaque()
var content = CFRunLoopObserverContext(version: 0, info: controllerPoint, retain: nil, release: nil, copyDescription: nil)
runloopObserver = CFRunLoopObserverCreate(nil, CFRunLoopActivity.beforeWaiting.rawValue, true, 0, { (oberver, activity, info) in
if info == nil {//如果没有取到 直接返回
return
}
let controller = Unmanaged<ViewController>.fromOpaque(info!).takeUnretainedValue()
if controller.isKind(of: PicturesDetailViewController.self) {
controller.runloopCall()
}
}, &content)
CFRunLoopAddObserver(runloop, runloopObserver, CFRunLoopMode.commonModes)
}
注意: 如果这里使用takeRetainedValue 、passRetained方法，会崩溃，我理解的是标明为retain的值，在使用后ARC会自动将它release一次，这样在某个时候self对象就会被释放了，当runloop再次用到self的时候就会崩溃。如果用unretain的值，ARC就不会去retain和release这个指针对象。
不建议的方式
看下面代码:
func addRunloopOberver() {
let controllerPoint = unsafeBitCast(self, to: UnsafeMutableRawPointer.self)
var content = CFRunLoopObserverContext(version: 0, info: controllerPoint, retain: nil, release: nil, copyDescription: nil)
runloopObserver = CFRunLoopObserverCreate(nil, CFRunLoopActivity.beforeWaiting.rawValue, true, 0, { (oberver, activity, info) in
if info == nil {//如果没有取到 直接返回
return
}
let controller = unsafeBitCast(info, to: PicturesDetailViewController.self)
if controller.isKind(of: ViewController.self) {
controller.runloopCall()
}
}, &content)
CFRunLoopAddObserver(runloop, runloopObserver, CFRunLoopMode.commonModes)
}
上面使用了unsafeBitCast方法，强行将self对象转换为指针，最后也是强行转换回来。虽然说也可以运行，但是官方文档中建议，不到万不得已不要使用这个方法，特别危险。。
下面是官方文档原文
Use this function only to convert the instance passed as x to a layout-compatible type when conversion through other means is not possible. Common conversions supported by the Swift standard library include the following:
Warning
Calling this function breaks the guarantees of the Swift type system; use with extreme care.
- Value conversion from one integer type to another. Use the destination type’s initializer or the numericCast(_:) function.
- Bitwise conversion from one integer type to another. Use the destination type’s init(truncatingIfNeeded:) or init(bitPattern:) initializer.
- Conversion from a pointer to an integer value with the bit pattern of the pointer’s address in memory, or vice versa. Use the init(bitPattern:) initializer for the destination type.
- Casting an instance of a reference type. Use the casting operators (as, as!, or as?) or the unsafeDowncast(:to:) function. Do not use unsafeBitCast(:to:) with class or pointer types; doing so may introduce undefined behavior.
