<!--定義-->
@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
}

var age = 10
age = withUnsafePointer(to: &age) { ptr in
    //返回Int整型值
    return ptr.pointee + 12
}
print(age)

var age = 10
//分配容量大小，為8字節(jié)
let ptr = UnsafeMutablePointer<Int>.allocate(capacity: 1)
//初始化
ptr.initialize(to: age)
ptr.deinitialize(count: 1)
ptr.pointee += 12
print(ptr.pointee)
//釋放
ptr.deallocate()

struct CJLTeacher {
    var age = 10
    var height = 1.85
}
var t = CJLTeacher()

//分配兩個(gè)CJLTeacher大小的空間
let ptr = UnsafeMutablePointer<CJLTeacher>.allocate(capacity: 2)
//初始化第一個(gè)空間
ptr.initialize(to: CJLTeacher())
//移動(dòng)，初始化第2個(gè)空間
ptr.successor().initialize(to: CJLTeacher(age: 20, height: 1.75))
//訪問(wèn)方式一
print(ptr[0])
print(ptr[1])
//訪問(wèn)方式二
print(ptr.pointee)
print((ptr+1).pointee)
//訪問(wèn)方式三
print(ptr.pointee)
//successor 往前移動(dòng)
print(ptr.successor().pointee)
//必須和分配是一致的
ptr.deinitialize(count: 2)
//釋放
ptr.deallocate()

struct HeapObject {
    var kind: Int
    var strongRef: UInt32
    var unownedRef: UInt32
}
class CJLTeacher{
    var age = 18
}
var t = CJLTeacher()

//將t綁定到結(jié)構(gòu)體內(nèi)存中
//1、獲取實(shí)例變量的內(nèi)存地址，聲明成了非托管對(duì)象
/*
 通過(guò)Unmanaged指定內(nèi)存管理，類似于OC與CF的交互方式（所有權(quán)的轉(zhuǎn)換 __bridge）
 - passUnretained 不增加引用計(jì)數(shù)，即不需要獲取所有權(quán)
 - passRetained 增加引用計(jì)數(shù)，即需要獲取所有權(quán)
 - toOpaque 不透明的指針
 */
let ptr = Unmanaged.passUnretained(t as AnyObject).toOpaque()
//2、綁定到結(jié)構(gòu)體內(nèi)存,返回值是UnsafeMutablePointer<T>
/*
 - bindMemory 更改當(dāng)前 UnsafeMutableRawPointer 的指針類型，綁定到具體的類型值
    - 如果沒(méi)有綁定，則綁定
    - 如果已經(jīng)綁定，則重定向到 HeapObject類型上
 */
let heapObject = ptr.bindMemory(to: HeapObject.self, capacity: 1)
//3、訪問(wèn)成員變量
print(heapObject.pointee.kind)
print(heapObject.pointee.strongRef)
print(heapObject.pointee.unownedRef)

var tul = (10, 20)
//UnsafePointer<T>
func testPointer(_ p : UnsafePointer<Int>){
    print(p)
}
withUnsafePointer(to: &tul) { (tulPtr: UnsafePointer<(Int, Int)>) in
    //不能使用bindMemory，因?yàn)橐呀?jīng)綁定到具體的內(nèi)存中了
    //使用assumingMemoryBound，假定內(nèi)存綁定，目的是告訴編譯器ptr已經(jīng)綁定過(guò)Int類型了，不需要再檢查memory綁定
    testPointer(UnsafeRawPointer(tulPtr).assumingMemoryBound(to: Int.self))
}

struct HeapObject {
    var strongRef: UInt32 = 10
    var unownedRef: UInt32 = 20
}
func testPointer(_ p: UnsafePointer<Int>){
   print(p)
}
//實(shí)例化
var  t = HeapObject()
//獲取結(jié)構(gòu)體屬性的指針傳入函數(shù)
withUnsafePointer(to: &t) { (ptr: UnsafePointer<HeapObject>) in
    //1. 獲取變量
    let strongRef = UnsafeRawPointer(ptr) + MemoryLayout<HeapObject>.offset(of: \HeapObject.strongRef)!
    //2. 傳遞strongRef屬性的值
    testPointer(strongRef.assumingMemoryBound(to: Int.self))
}

var age = 10
func testPointer(_ p: UnsafePointer<Int64>){
   print(p)
}
let ptr = withUnsafePointer(to: &age) {$0}
ptr.withMemoryRebound(to: Int64.self, capacity: 1) { (ptr: UnsafePointer<Int64>)  in
    testPointer(ptr)
}