swift中的指针分为两类
typed pointer
指定数据类型指针,即UnsafePointer<T>
,其中T表示泛型raw pointer
未指定数据类型的指针(原生指针
) ,即UnsafeRawPointer
swift与OC指针对比如下:
原生指针
原生指针:是指未指定数据类型的指针,有以下说明
-
对于指针的内存管理是需要手动管理的
-
指针在使用完需要手动释放
-
原生指针的使用
//原生指针
//对于指针的内存管理是需要手动管理的
//定义一个未知类型的指针:本质是分配32字节大小的空间,指定对齐方式是8字节对齐
let p = UnsafeMutableRawPointer.allocate(byteCount: 32, alignment: 8)
//存储
for i in 0..<4 {
p.storeBytes(of: i + 1, as: Int.self)
}
//读取
for i in 0..<4 {
//p是当前内存的首地址,通过内存平移来获取值
let value = p.load(fromByteOffset: i * 8, as: Int.self)
print("index: \(i), value: \(value)")
}
//使用完成需要dealloc,即需要手动释放
p.deallocate()
- 通过运行发现,在读取数据时有问题,原因是因为读取时指定了每次读取的大小,但是存储是直接在8字节的p中存储了i+1,即可以理解为并没有指定存储时的内存大小
- 修改:通过advanced(by:)指定存储时的步长
//存储
for i in 0..<4 {
//指定当前移动的步数,即i * 8
p.advanced(by: i * 8).storeBytes(of: i + 1, as: Int.self)
}
- 运行结果如下
type pointer (泛型指针)
- 查看
withUnsafePointer
(to:的定义中,第二个参数传入的是闭包表达式,然后通过rethrows重新抛出Result(即闭包表达式产生的结果)了,所以可以将闭包表达式进行简写(简写参数、返回值),其中$0
表示第一个
参数,$1
表示第二个
参数,以此类推
<!--定义-->
@inlinable public func withUnsafePointer<T, Result>(to value: inout T, _ body: (UnsafePointer<T>) throws -> Result) rethrows -> Result
<!--使用1-->
var age = 10
let p = withUnsafePointer(to: &age) { $0 }
print(p)
<!--使用2-->
withUnsafePointer(to: &age){print($0)}
<!--使用3-->
//其中p1的类型是 UnsafePointer<Int>
let p1 = withUnsafePointer(to: &age) { ptr in
return ptr
}
- 通过
pointee
访问属性
可以通过指针的pointee属性访问变量值,如下所示
var age = 10
let p = withUnsafePointer(to: &age) { $0 }
print(p.pointee)
<!--打印结果-->
10
- 修改指针的值
间接修改
:需要在闭包中直接通过ptr.pointee修改并返回。类似于char *p = “Q” 中的 *p,因为访问Q通过 *p
var age = 10
age = withUnsafePointer(to: &age) { ptr in
//返回Int整型值
return ptr.pointee + 12
}
print(age)
直接修改-方式1
:也可以通过withUnsafeMutablePointer
方法,即创建方式一
var age = 10
withUnsafeMutablePointer(to: &age) { ptr in
ptr.pointee += 12
}
直接修改-方式2
:通过allocate
创建UnsafeMutablePointer
,需要注意的是
initialize
与deinitialize
是成对
的- deinitialize中的count与申请时的capacity需要一致
- 需要deallocate
var age = 10
//分配容量大小,为8字节
let ptr = UnsafeMutablePointer<Int>.allocate(capacity: 1)
//初始化
ptr.initialize(to: age)
ptr.deinitialize(count: 1)
ptr.pointee += 12
print(ptr.pointee)
//释放
ptr.deallocate()
指针使用实例
实例一: 访问结构体实例对象
- 定义一个结构体
struct QTeacher {
var age = 18
var height = 180
}
var t = QTeacher()
-
使用UnsafeMutablePointer创建指针,并通过指针访问CJLTeacher实例对象,有以下三种方式:
-
方式一:下标访问
-
方式二:内存平移
-
方式三:successor
-
//分配两个CJLTeacher大小的空间
let ptr = UnsafeMutablePointer<QTeacher>.allocate(capacity: 2)
//初始化第一个空间
ptr.initialize(to: QTeacher())
//移动,初始化第2个空间
ptr.successor().initialize(to: QTeacher(age: 20, height: 190))
//访问方式一
print(ptr[0])
print(ptr[1])
//访问方式二
print(ptr.pointee)
print((ptr+1).pointee)
//访问方式三
print(ptr.pointee)
//successor 往前移动
print(ptr.successor().pointee)
//必须和分配是一致的
ptr.deinitialize(count: 2)
//释放
ptr.deallocate()
实例二:实例对象绑定到struct内存
Unmanaged
通过Unmanaged指定内存管理
,类似于OC与CF的交互方式(所有权的转换
__bridge)
- passUnretained 不增加引用计数,即不需要获取所有权
不需要获取所有权 使用unretain
- passRetained 增加引用计数,即需要获取所有权
create\copy 需要使用retain
- toOpaque 不透明的指针
let ptr = Unmanaged.passUnretained(t as AnyObject).toOpaque()
\
let ptr = Unmanaged.passRetained(t as AnyObject).toOpaque()
bindMemory
bindMemory 更改当前 UnsafeMutableRawPointer
的指针类型
,绑定
到具体
的类型
值
-
如果没有绑定,则绑定
- 如果已经绑定,则重定向到 HeapObject类型上
let heapObject = ptr.bindMemory(to: HeapObject.self, capacity: 1)
实例: 1、将类的实例对象绑定到HeapObject上
struct HeapObject {
var kind: Int
var strongRef: UInt32
var unownedRef: UInt32
}
class QTeacher{
var age = 18
}
var t = QTeacher()
- 将类的实例对象绑定到HeapObject上
struct HeapObject {
var kind: Int
var strongRef: UInt32
var unownedRef: UInt32
}
class QTeacher{
var age = 18
}
var t = QTeacher()
let ptr = Unmanaged.passUnretained(t as AnyObject).toOpaque()
let heapObject = ptr.bindMemory(to: HeapObject.self, capacity: 1)
print(heapObject.pointee)
- 其运行结果如下:
实例:2、绑定到类结构
- 将swift中的类结构定义成一个结构体
struct q_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
}
- 将t改成绑定到q_swift_class
//1、绑定到q_swift_class
let metaPtr = heapObject.pointee.kind.bindMemory(to: q_swift_class.self, capacity: 1)
//2、访问
print(metaPtr.pointee)
- 运行结果如下,其本质原因是因为 metaPtr 和 q_swift_class的类结构是一样的
实例三:元组指针类型转换
assumingMemoryBound
:假定内存绑定
当前指针已经绑定了类型,告诉编译器,当前对象已经绑定了对应的类型了,不需要再去检查类型。
-
assumingMemoryBound 与 bindMemory区别是:
- assumingMemoryBound已经绑定到具体的内存中了
- bindMemory没有绑定到具体的内存中
var t = (10,20)
func testPointer(_ p : UnsafeRawPointer){
p.assumingMemoryBound(to: Int.self)
print(p)
}
withUnsafePointer(to: &t) { (ptr : UnsafePointer<(Int,Int)>) in
testPointer(UnsafeRawPointer(ptr).assumingMemoryBound(to: Int.self))
}
实例四:如何获取结构体的属性的指针
1、定义实例变量
2、获取实例变量的地址,并将strongRef的属性值传递给函数
struct HeapObject {
var strongref = 10
var unownedRef = 20
}
var t = HeapObject()
withUnsafePointer(to: &t) { (ptr:UnsafePointer<HeapObject>) in
//思考这里是否需要通过withUnsafePointer来获取?
//1、withUnsafePointer(to: &ptr.pointee.strongref, <#T##body: (UnsafePointer<T>) throws -> Result##(UnsafePointer<T>) throws -> Result#>)?
//2、ptr.advanced(by: <#T##Int#>)?
//3、是不是通过原生指针 + 偏移量
let strongRefPtr = UnsafeRawPointer(ptr) + MemoryLayout<HeapObject>.offset(of: \HeapObject.strongref)!
testPointer(strongRefPtr.assumingMemoryBound(to: Int.self))
}
实例五: 通过 withMemoryRebound 临时绑定内存类型
- 如果方法的类型与传入参数的类型不一致,会报错
- 解决办法:通过
withMemoryRebound
临时绑定内存类型
var t = 20
func testPointer(_ p : UnsafePointer<Int64>){
print(p)
}
var ptr = withUnsafePointer(to: &t) { $0
}
ptr.withMemoryRebound(to: Int64.self, capacity: 1) { (ptr:UnsafePointer<Int64>) in
testPointer(ptr)
}
实例六:unsafeBitCast 按位强转
按位强转是非常危险的,指针的位数必须要一致。
struct StructMetadata{
var kind: Int
var typeDescriptor: UnsafeMutablePointer<StructDescriptor>
}
struct LGTeacher{
var age = 18
var name = "Kody"
var age1 = 20
// var name1 = "LG"
}
var t = LGTeacher()
var t1 = LGTeacher.self
let ptr = unsafeBitCast(LGTeacher.self as Any.Type, to: UnsafeMutablePointer<StructMetadata>.self)
let namePtr = ptr.pointee.typeDescriptor.pointee.name.get()
print(String(cString: namePtr))
print(ptr.pointee.typeDescriptor.pointee.NumFields)
小结:
-
withMemoryRebound
: 临时更改内存绑定类型 -
bindMemory(to: Capacity:)
:更改内存绑定的类型,如果之前没有绑定,那么就是首次绑定,如果绑定过了,会被重新绑定为该类型 -
assumingMemoryBound
假定内存绑定,这里就是告诉编译器:我的类型就是这个,你不要检查我了,其实际类型还是原来的类型 -
Unmanaged
:指定内存管理
,类似于OC与CF的交互方式(所有权的转换
__bridge) -
unsafeBitCast
:按位强转