指针类型
是不安全的
1.UnsafePointer<Pointee> 类似于const Pointee * 只可以用来访问内存 不可以修改
2.UnsafeMutablePointer<Pointee> 类似于Pointee * 可以用来访问内存 可以修改
3.UnsafeRawPointer 类似于const void * 不支持泛型
4.UnsafeMutableRawPointer 类似于void * 不支持泛型
var age = 10
func test1(_ ptr: UnsafeMutablePointer<Int>){
ptr.pointee += 10
}
func test2(_ ptr: UnsafePointer<Int>){
print(ptr.pointee)
//ptr.pointee 取出指针指向的数据
}
test1(&age)
test2(&age)
print(age)
20
20
ptr.pointee 取出指针指向的数据
func test3(_ ptr: UnsafeRawPointer){
let d = ptr.load(as: Int.self)
print("test3",d)
}
func test4(_ ptr: UnsafeMutableRawPointer){
//不支持泛型 那么就要自己设置是什么类型 传入什么值
ptr.storeBytes(of: 30, as: Int.self)
}
test3(&age)
test4(&age)
print(age)
ptr.load(as: Int.self) 指针指向的Int数据
ptr.storeBytes(of: 30, as: Int.self) 把数据存储到指针指向的空间
指针的应用
var arr = NSArray(objects: 11,22,33,44)
arr.enumerateObjects { (element, idx, stop) in
print(idx,element)
if idx == 2 {
stop.pointee = true
}
}
stop.pointee 代表执行完大括号之后再判断条件是否满足 是否继续执行
可读行更好
var arr = NSArray(objects: 11,22,33,44)
for (idx,element) in arr.enumerated() {
print(idx,element)
if idx == 2 {
break
}
}
获得指向某个变量的指针
var age = 10
var ptr = withUnsafePointer(to: &age) { $0 }
var ptr2 = withUnsafeMutablePointer(to: &age) { $0
}
ptr2.pointee = 30
print(age)
var age = 10
var ptr = withUnsafePointer(to: &age) { UnsafeRawPointer($0)
}
var ptr2 = withUnsafeMutablePointer(to: &age) { UnsafeMutableRawPointer($0)
}
ptr2.storeBytes(of: 30, as: Int.self)
print(ptr.load(as: Int.self))
print(age)
获得指向堆空间实例的指针
class Person {
var age: Int
init(age: Int) {
self.age = age
}
}
var person = Person(age: 21)
var ptr = withUnsafePointer(to: &person) { UnsafeRawPointer($0)
}
//ptr 指向person这个指针变量 存放person这个指针变量的地址值
//ptr.pointee 等价于person
print(ptr)
var ptr2 = UnsafeMutableRawPointer(bitPattern: ptr.load(as: UInt.self))
print(ptr2 ?? 2)
//ptr2 堆空间地址值 Person的地址值
创建指针
var ptr = malloc(16)
//往堆空间里面放入数据
ptr?.storeBytes(of: 10, as: Int.self)
ptr?.storeBytes(of: 20, toByteOffset: 8, as: Int.self)
print(ptr!)
free(ptr)
var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)
//指针偏移 8个字节
ptr.advanced(by: 8)
//把22存放在后8个字节
ptr.advanced(by: 8).storeBytes(of: 22, as: Int.self)
//释放
ptr.deallocate()
//capacity 是容量 相当于Int的8个字节 * 3 = 24个字节
var ptr = UnsafeMutablePointer<Int>.allocate(capacity: 2)
ptr.pointee = 10
ptr.advanced(by: 8).pointee = 20
//初始化内存 用10初始化前8个字节
ptr.initialize(to: 10)
//连续的是2个8个字节的10 初始化内存
ptr.initialize(repeating: 10, count: 2)
//successor 后记 跳8个字节(如果是Int) 下一个8个字节初始化10
ptr.successor().initialize(to: 10)
//取出下一个字节的内容
print(ptr.successor().pointee)
print((ptr + 1).pointee)
print(ptr[0])
print(ptr[1])
//反初始化 防止内存泄露
ptr.deinitialize(count: 3)
//释放
ptr.deallocate()
class Person {
var age: Int
var name: String
init(age: Int, name: String) {
self.age = age
self.name = name
}
deinit {
print(name,"deinit")
}
}
var ptr = UnsafeMutablePointer<Person>.allocate(capacity: 3)
ptr.initialize(to: Person(age: 20, name: "jack"))
(ptr + 1).initialize(to: Person(age: 21, name: "Rose"))
(ptr + 2).initialize(to: Person(age: 22, name: "Kate"))
//ptr[2].name
ptr.deinitialize(count: 3)
ptr.deallocate()
初始化多少内存 就要反初始化多少内存 否则 内存泄露
指针之间的转换
var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)
//转换为UnsafeMutablePointer指针
var ptr2 = ptr.assumingMemoryBound(to: Int.self)
//ptr2 是泛型的 ptr2 + 1 就是移动8个字节
var ptr4 = ptr2 + 1
//ptr 不是泛型的 就是移动8个字节
var ptr3 = (ptr + 8).assumingMemoryBound(to: Int.self)
//强制转换
var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)
var ptr5 = unsafeBitCast(ptr, to: Int.self)
unsafeBitCast 是忽略数据类型的强制转换 不会因为数据类型的变化而改变原来的内存数据
unsafeBitCast
var person = Person()
//把person里面的内容放入ptr 内存数据是一样的 类型不同
var ptr = unsafeBitCast(person, to: UnsafeRawPointer.self)
print(ptr)
