class Animal {
    deinit {
        print("Animal deinit")
    }
}

func test() {
    let animal = Animal()
}

print("will deinit")
test()
print("did deinit")

var a1: Animal? = Animal()
print("will deinit")
a1 = nil
print("did deinit")

weak var a2: Animal? = Animal()

// 以下兩種方式都會(huì)報(bào)錯(cuò)的
weak var a2: Animal = Animal()
weak let a2: Animal? = Animal()

// 該協(xié)議表示只能被類遵守, AnyObject代表所有的類實(shí)例
protocol Liveable: AnyObject {}
class Person {}

weak var p0: Person?
weak var p1: AnyObject?
// 所有能遵循Liveable協(xié)議的肯定都是類
weak var p2: Liveable?

unowned var p10: Person?
unowned var p11: AnyObject?
unowned var p12: Liveable?

class Person {
    var fn: (() -> ())?
    func run() { print("run") }
    deinit { print("deinit") }
}

func test() {
    let p = Person()
    p.fn = { 
        p.run()
    }
}

test()

// 使用weak
func test() {
    let p = Person()
    p.fn = { [weak p] in
        p?.run()
    }
}

// 使用unowned
func test() {
    let p = Person()
    p.fn = { [unowned p] in
        p.run()
    }
}

func test() {
    let p = Person()
    p.fn = { [unowned p] in
        p.run()
    }
}

// 和上面等價(jià)代碼
func test() {
    let p = Person()
    p.fn = { [unowned ownedP = p, weak weakP = p] in
        ownedP.run()
        // weakP?.run()
    }
}

class Person {
    var fn: ((Int) -> ())?
    func run() { print("run") }
    deinit { print("deinit") }
}

func test() {
    let p = Person()
    p.fn = {
        (num) in
        print("num = \(num)")
    }
}

func test() {
    let p = Person()
    p.fn = {
        [weak p](num) in
        print("num = \(num)")
        p?.run()
    }
}

class Person {
    lazy var fn: (() -> ()) = {
        self.run()
    }
    func run() { print("run") }
    deinit { print("deinit") }
}

func test() {
    let p = Person()
    p.fn()
}

test()

// weak解決循環(huán)引用
lazy var fn: (() -> ()) = {
    [weak self] in
    self?.run()
}

// unowned解決循環(huán)引用
lazy var fn: (() -> ()) = {
    [unowned self] in
    self.run()
}

class Student {
    var age: Int = 2
    lazy var getAge: Int = {
        self.age
    }()
    deinit { print("deinit") }
}

func test() {
    let p = Student()
    print(p.getAge)
}

test()

/* 輸出結(jié)果
2
deinit
*/

// 存在循環(huán)引用
class Person {
    lazy var fn: (() -> ()) = {
        self.run()
    }
    func run() { print("run") }
    deinit { print("deinit") }
}

// 不存在循環(huán)引用
class Student {
    var age: Int = 2
    lazy var getAge: Int = {
        self.age
    }()
    deinit { print("deinit") }
}

// getAge也可以寫成如下形式
lazy var getAge: Int = {
    return self.age
}()

// 也可以理解為
lazy var getAge: Int = self.age

// 不存在內(nèi)存訪問(wèn)沖突
var number = 1
func plus(_ num: inout Int) -> Int {
    return num + 1
}
number = plus(&number)

// 存在內(nèi)存訪問(wèn)沖突
var step = 1
func increment(_ num: inout Int) {
    num += step
}
increment(&step)

// 改變兩個(gè)傳入?yún)?shù)的值, 讀取并修改傳入?yún)?shù)的值
func balance(_ x: inout Int, _ y: inout Int) {
    let sum = x + y
    x = sum / 2
    y = sum - x
}

// 定義Player結(jié)構(gòu)體
struct Player {
    var name: String
    var health: Int
    var energy: Int
    mutating func shareHealth(with teammate: inout Player) {
        balance(&teammate.health, &health)
    }
}

// 這里讀寫的是同一個(gè)maria
var maria = Player(name: "Maria", health: 50, energy: 10)
balance(&maria.health, &maria.energy)

// 這里讀寫的是同一個(gè)tuple
var tuple = (health: 10, energy: 20)
balance(&tuple.health, &tuple.energy)

// 這里可以在局部作用域內(nèi)定義成局部變量, 就不會(huì)有問(wèn)題了
func test() {
    var maria = Player(name: "Maria", health: 50, energy: 10)
    var tuple = (health: 10, energy: 20)
    balance(&tuple.health, &tuple.energy)
    balance(&maria.health, &maria.energy)
}

class Person {}
var person = Person()

// 獲取可變的變量指針, value參數(shù)接受變量地址
@inlinable public func withUnsafeMutablePointer<T, Result>(to value: inout T, _ body: (UnsafeMutablePointer<T>) throws -> Result) rethrows -> Result
// 獲取不可變的變量指針, value參數(shù)接受變量
@inlinable public func withUnsafePointer<T, Result>(to value: T, _ body: (UnsafePointer<T>) throws -> Result) rethrows -> Result
// 獲取不可變的變量指針, value參數(shù)接受變量地址
@inlinable public func withUnsafePointer<T, Result>(to value: inout T, _ body: (UnsafePointer<T>) throws -> Result) rethrows -> Result

var age = 10
var ptr1 = withUnsafeMutablePointer(to: &age) { $0 }   // UnsafeMutablePointer<Int>
var ptr2 = withUnsafePointer(to: &age) { $0 }          // UnsafePointer<Int>
ptr1.pointee = 22
print(ptr2.pointee) // 22
print(ptr2)         // 0x0000000100008310

var ptr3 = withUnsafeMutablePointer(to: &age) { UnsafeMutableRawPointer($0) }   // UnsafeMutableRawPointer
var ptr4 = withUnsafePointer(to: &age) { UnsafeRawPointer($0) }                 // UnsafeRawPointer
// as參數(shù)是需要存儲(chǔ)什么類型的數(shù)據(jù)
ptr3.storeBytes(of: 33, as: Int.self)
print(ptr4.load(as: Int.self)) // 33
print(ptr4)         // 0x0000000100008310

// 根據(jù)需要分配的內(nèi)存大小創(chuàng)建一個(gè)指針
public func malloc(_ __size: Int) -> UnsafeMutableRawPointer!
// 釋放內(nèi)存
public func free(_: UnsafeMutableRawPointer!)


// 下面這兩個(gè)函數(shù), 是賦值和取值的函數(shù), 之前簡(jiǎn)單介紹過(guò)
// 參數(shù)一: 需要存儲(chǔ)的值
// 參數(shù)二: 偏移量, 從第幾個(gè)字節(jié)開(kāi)始存儲(chǔ), 默認(rèn)從第一個(gè)
// 參數(shù)三: 需要存儲(chǔ)的值的類型
@inlinable public func storeBytes<T>(of value: T, toByteOffset offset: Int = 0, as: T.Type)

// 參數(shù)一: 偏移量, 從第幾個(gè)字節(jié)開(kāi)始存儲(chǔ), 默認(rèn)從第一個(gè)
// 參數(shù)二: 需要存儲(chǔ)的值的類型
@inlinable public func load<T>(fromByteOffset offset: Int = 0, as type: T.Type) -> T

// 創(chuàng)建指針
var ptr = malloc(16)
// 存儲(chǔ)值
ptr?.storeBytes(of: 10, as: Int.self)
// 這里toByteOffset參數(shù)如果傳0, 就會(huì)覆蓋前8個(gè)字節(jié)的數(shù)據(jù)
ptr?.storeBytes(of: 12, toByteOffset: 8, as: Int.self)
// 取值
print(ptr?.load(as: Int.self) ?? 0)
print(ptr?.load(fromByteOffset: 8, as: Int.self) ?? 0)
// 銷毀, 釋放內(nèi)存
free(ptr)

// byteCount: 需要申請(qǐng)的字節(jié)數(shù), alignment: 對(duì)其字節(jié)數(shù)
var ptr2 = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)
// 存儲(chǔ)
ptr2.storeBytes(of: 9, as: Int.self)

// 根據(jù)字節(jié)偏移存儲(chǔ)
// 這里的ptr3是ptr2偏移8個(gè)字節(jié)的新的指針地址
var ptr3 = ptr2.advanced(by: 8)  // UnsafeMutableRawPointer
ptr3.storeBytes(of: 12, as: Int.self)

// 上面這種方式等價(jià)于
ptr2.storeBytes(of: 12, toByteOffset: 8, as: Int.self)

// 取值同樣
print(ptr2.load(as: Int.self))
// 下面這兩種取值方式也是一樣的
print(ptr2.advanced(by: 8).load(as: Int.self))
print(ptr2.load(fromByteOffset: 8, as: Int.self))

// 釋放內(nèi)存
ptr2.deallocate()

// capacity: 容量, 即可以存儲(chǔ)3個(gè)Int類型的數(shù)據(jù), 也就是24個(gè)字節(jié)
var ptr = UnsafeMutablePointer<Int>.allocate(capacity: 3)
// 初始化內(nèi)存, 用10初始化錢8個(gè)字節(jié)
ptr.initialize(to: 10)
// 用10初始化前兩個(gè)容量的內(nèi)存, 即16個(gè)字節(jié)
ptr.initialize(repeating: 10, count: 2)
// 使用successor獲取下一個(gè)存儲(chǔ)位, 也就是下一個(gè)Int的位置
var ptr1 = ptr.successor()  //  UnsafeMutablePointer<Int>
ptr1.initialize(to: 20)
// 存儲(chǔ)第三個(gè)Int值
ptr.successor().successor().initialize(to: 30)

// 取值的兩種方式
print(ptr.pointee)        // 第一個(gè)值
print((ptr + 1).pointee)  // 第二個(gè)值
print((ptr + 2).pointee)  // 第三個(gè)值

// 下面這種方式和上面等價(jià)
print(ptr[0])
print(ptr[1])
print(ptr[2])

// 前面如果使用了initialize, 則必須調(diào)用反初始化
// 而且count要和上面allocate(capacity: 3)的capacity一致, 否則會(huì)造成內(nèi)存泄露的問(wèn)題
ptr.deinitialize(count: 3)
ptr.deallocate()

public init<T>(_ other: UnsafeMutablePointer<T>)

var ptr = UnsafeMutablePointer<Int>.allocate(capacity: 3)
var ptr1 = UnsafeMutableRawPointer(ptr)

public func assumingMemoryBound<T>(to: T.Type) -> UnsafePointer<T>

var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)
var ptr1 = ptr.assumingMemoryBound(to: Int.self)
// 初始化前8個(gè)字節(jié)
ptr1.pointee = 11
// 初始化后8個(gè)字節(jié)
// 特別注意, 這里的(ptr + 8)是指ptr向后偏移8個(gè)字節(jié), 要和之前的區(qū)分開(kāi)
(ptr + 8).assumingMemoryBound(to: Int.self).pointee = 12

ptr.deallocate()

// 把第一個(gè)參數(shù)類型轉(zhuǎn)成第二個(gè)參數(shù)類型
@inlinable public func unsafeBitCast<T, U>(_ x: T, to type: U.Type) -> U


var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)
unsafeBitCast(ptr, to: UnsafeMutablePointer<Int>.self).pointee = 13
// 注意, 這里的(ptr + 8)是指ptr向后偏移8個(gè)字節(jié), 要和之前的區(qū)分開(kāi)
unsafeBitCast(ptr + 8, to: UnsafeMutablePointer<Double>.self).pointee = 14.23

ptr.deallocate()