Manual Memery Managment In Swift

Swift中的指针与C的对应关系

UnsafePointer<T>                    const T *
UnsafeMutablePointer                T *
UnsafeBufferPointer                 const T * //指向一个连续已知类型区域
UnsafeMutableBufferPointer          T * //指向一个连续已知类型区域
UnsafeRawPointer                    const void *
UnsafeMutableRawPointer             void *
UnsafeRawBufferPointer              const void * //指向一个连续未知类型区域
UnsafeMutableRawBufferPointer       void *  //指向一个连续未知类型区域

全局操作函数

//将第一个参数T以指针的形式传递给closure
func withUnsafePointer<T, Result>(to: T, (UnsafePointer<T>) -> Result) -> Result
func withUnsafePointer<T, Result>(to: inout T, (UnsafePointer<T>) -> Result) -> Result
func withUnsafeMutablePointer<T, Result>(to: inout T, (UnsafeMutablePointer<T>) -> Result) -> Result

//将第一个参数以无类型指向的方式传递给closure
func withUnsafeBytes<T, Result>(of: T, (UnsafeRawBufferPointer) -> Result) -> Result
func withUnsafeBytes<T, Result>(of: inout T, (UnsafeRawBufferPointer) -> Result) -> Result
func withUnsafeMutableBytes<T, Result>(of: inout T, (UnsafeMutableRawBufferPointer) -> Result) -> Result

//交换两个变量的值
func swap<T>(inout T, inout T)

//保持变量T在closure里面是不会被销毁的
//可以使用在异常调用的时候,可保证变量T的生命同期
func withExtendedLifetime<T, Result>(T, (T) -> Result) -> Result
func withExtendedLifetime<T, Result>(T, () -> Result) -> Result

Unmanged: https://www.jianshu.com/p/624706ac006a

常用方法

UnsafePointer

//将指针的类型转换成一个临时的给定类型的指针传递给closure
func withMemoryRebound<T, Result>(to: T.Type, capacity: Int, (UnsafePointer<T>) -> Result) -> Result

//向下移动一位,并返回一个新的指针 
func successor() -> UnsafePointer<Pointee>
//向上移动一位,并返回一个新的指针
func predecessor() -> UnsafePointer<Pointee>

RawPointer

//转换给指定类型的指针
func assumingMemoryBound<T>(to: T.Type) -> UnsafeMutablePointer<T>
//转换成指定类型的指针,capacity指定了这个指针读取的T数据数量
func bindMemory<T>(to type: T.Type, capacity count: Int) -> UnsafeMutablePointer<T>

func foo(_ p: UnsafeRawPointer) {
    let buffer = UnsafeBufferPointer<Int>.init(start: p.bindMemory(to: Int.self, capacity: 2), count: 2)
    //let buffer = UnsafeBufferPointer<Int>.init(start: p.assumingMemoryBound(to: Int.self), count: 5)
    buffer.forEach {
        print($0)
    }
    
}
foo([1,2,3,4,5])

在使用时可以发现bindMemory与assumingMemoryBound在操作连续空间时好像没有那么明确的界限了

BufferPointer

BufferPointer实现了Collection,因此可以直接使用Collection中的各种方法来遍历操作数据,filter,map...,Buffer可以实现对一块连续存在空间进行操作,类似C中的数姐的指针.
UnsafeBufferPointer指定了类型,UnsafeMutableRawPointer=UnsafeBufferPointer<UInt8>

函数在Swift中的使用

1.变量隐式的转换成指针

变量是一个常量的情况:

func takesAPointer(_ p: UnsafePointer<Float>) {
    print(p.pointee)
}
var x: Float = 100.0
takesAPointer(&x)
//打印的结果是 100.0

如果常量是一个数组呢?

takesAPointer([1,2,3,4])
//打印的结果是1

这是为什么呢？
因为p当前指向的是数组的首地址,按Float的长度读取出来的数据就是数组的第一个元素,那如果我们要读取后面的元素怎么办呢?

func takesAPointer(_ p: UnsafePointer<Float>) {
    print(p.pointee)
    var newPointer = p
    newPointer += 1
    print(newPointer.pointee)
}
//打印的结果是1.0, 2.0

我们可以对指针进行移位,这就你C里面对指针的操作是一样的,+1就会指向下一个元素
有些人会问,这个操作一点也不Swift...Swift也许有更好的理解,那就是Buffer:
UnsafeBufferPointer<T>,它是一个实现了Collection的类,让我们可以向操作普通的Collection一样操作一个指针,这看起来很Swift,看看代码吧:

let buffer = UnsafeBufferPointer<Float>.init(start: p, count: 4)
buffer.forEach {
    print($0)
}

一个字符串值，如果类型是Int8或UInt8。字符串会自动转换为UTF8，并将一个指向该缓冲区的指针传递给该函数。

func takesAPointer(_ p: UnsafePointer<UInt8>) {
    let buffer = UnsafeBufferPointer<UInt8>.init(start: p, count: 4)
    buffer.forEach {
        print($0)
    }
}

takesAPointer("Hellow Swift !")

还有一种就是函数参数是inout修饰的时候,我们需要传递的指针

func takesAPointer( _ p: inout Int) {
    p = 300
}
var val = 100
takesAPointer(&val)
print(val)
//打印结果是: 300

2.传递一个变量指针UnsafeMutablePointer

与第1点不同的是,这里函数指针指向的值是可以被改变的

func takesAPointer(_ p: UnsafeMutablePointer<Float>) {
    p.pointee = 2
}
var list = [1,2,3,4] as [Float]
takesAPointer(&list)
print(list)
//打印的结果是[2,2,3,4]

3.参数为自动释放的指向
用inout修饰的变量
4.参数为closure

func customCopyDescription(_ p: Int) -> Unmanaged<NSString> {
    
    let string: NSString = "参数是: \(p)" as NSString
    return Unmanaged.passRetained(string).autorelease()
}

func call(_ f: (Int) -> Unmanaged<NSString>) {
    print(f(9527).takeUnretainedValue())
}
call(customCopyDescription)

Swift是逃避不了指针这个话题的,由于它的设计初忠的原因,它使用了更优雅的方式更Swift的方式来表现指针,对接千千万万C语言的接口。正如他的全名一样,Unsafe已经表明了它是一个不安全的东西,请在使用的时候谨慎操作。
更多用法请参考Apple Develop Documents:https://developer.apple.com/documentation/swift/swift_standard_library/manual_memory_management