// // main.swift // class21 内存管理面试题为主基本都过气了没实践意义 // // Created by sakiko on 2026/4/7. // import Foundation print(Hello, World!) //Swift 使用自动引用计数ARC来管理堆上的内存(和OC一样即实例的内存分配和释放。 /* ARC的三种引用方式 1.强引用strong reference默认情况下引用都是强引用 2.弱引用weak~通过 weak 定义弱引用 必须是可选类型的var在实例销毁后ARC会自动将弱引用设置为nil ARC自动给弱引用设置nil时不会触发属性观察器 3.无主引用unowned~通过unowned定义无主引用 不会产生强引用实例销毁后仍然存储着实例的内存地址类似OC中的unsafe_unretained 试图在实例销毁后访问无主引用会产生运行时错误野指针 */ //释放指的是将不再需要的对象或变量从内存中删除以便释放内存资源使得其他对象可以使用这些内存。释放对象通常是在其生命周期结束时发生的。 //weak、unowned有使用限制只能用在类实例上 protocol Livable : AnyObject{} class Person{} //这是一个类 weak var p0: Person? //这是一个类实例 weak var p1: AnyObject? weak var p2: Livable? unowned var p10: Person? //这是一个类实例 unowned var p11: AnyObject? unowned var p12: Livable? //Autoreleasepool:Swift中用于管理【自动释放池】的一个功能主要用于控制内存的释放尤其是在存在大量临时对象的情况下(如循环或密集计算)。现在已经不用了随便看看就行了。 /* public func autoreleasepoolResult(invoking body: () throws - Result) rethrows - Result autoreleasepool { //这是一个闭包 let p MJPerson(age:20, name: Jack) p.run() } */ //循环引用(Reference Cycle)其实这里我完全看不懂 //循环引用发生在两个或多个对象相互持有对方的强引用导致它们无法被释放从而造成内存泄漏。这种情况会使得这些对象无法达到消亡的条件从而消耗系统资源。 //weak、unowned都能解决循环引用的问题unowned要比weak少一些性能消耗。所以 //在生命周期中可能会变为nil的使用weak //初始化赋值后再也不会变为nil的使用unowned //闭包的循环引用 //闭包表达式会默认对用到的外层对象产生额外的强引用(对外层对象进行了retain操作) //下面代码会产生循环引用导致Person对象无法释放(看不到Person的deinit被调用) class Person1 { var fn: (() - ())? func run() { print(run) } deinit { print(denit) } } func test() { let p Person1() p.fn { p.fn { [weak p] in p?.run() }//这是一个闭包强引用了p。由于闭包持有了对 Person1 对象的强引用这会导致Person1无法被释放导致内存泄漏。所以用weak来解决 } } test() func test1() { let p1 Person1() p1.fn { [unowned p1] in p1.run() }//这是一个闭包强引用了p1。由于闭包持有了对 Person1 对象的强引用这会导致Person1无法被释放导致内存泄漏。所以用unowned来解决 } test1() //这个是同时用了两个的看起来是一个终极版。 func test2() { let p2 Person1() p2.fn { [weak wp p2, unowned up p2, a 10 20] in wp?.run()//尝试调用 wp 的 run 方法。如果 p 被释放wp 会是 nil所以使用可选链?来安全调用。 //这里使用weak声明了一个弱引用wp即p2的弱引用。当p2被释放时wp会被设为nil这样就避免了循环引用的风险。 //使用unowned 声明了一个不拥有的引用up指向p2。这个引用假定在闭包内始终有效即p2在闭包执行期间不会被释放。如果p2 已经被释放而仍然尝试使用up程序会崩溃。 } } test2() //在闭包表达式的捕获列表声明weak或unowned引用解决循环引用问题 /* 注原来会导致循环引用的代码是这样的 func test() { let p Person1() p.fn {p.run()} } */ //闭包的循环引用 //如果想在定义闭包属性的同时引用self这个闭包必须是lazy的因为实例初始化完毕之后才能引用self class Person2 { lazy var fn: (() - ()) { [weak self] in//fn内部如果用到了实例成员(属性或方法这里是用到了run)编译器会强制要求明确写出self self?.run() } func run() {print(run)} deinit { print(deinit)} } //如果lazy属性是闭包调用的结果那么不用考虑循环引用的问题因为闭包调用后闭包的生命周期就结束了 class Person3 { var age: Int 0 lazy var getÅge: Int {//这行代码定义了一个闭包该闭包返回 self.age self.age }()//表示这个闭包在定义时立即执行并将结果即 self.age 的值赋给 getAge //因此getAge的值就是闭包执行的结果这里等于 0age 的初始值。 deinit{ print(deinit)} } //闭包就是把一个任务交给一个东西去做然后直接用这个返回的结果通常用在一个函数搞不定的办法。 //escaping //非逃逸闭包和逃逸闭包一般都是当做参数传递给函数 //非逃逸闭包闭包调用发生在函数结束前闭包调用在函数作用域内 //逃逸闭包闭包有可能在函数结束后调用闭包调用逃离了函数的作用域需要通过escaping声明 import Dispatch typealias Fn () - ()// func test1(_ fn: Fn){ fn() }//fn是非逃逸闭包(Fn在里面) var gFn: Fn? func test2(_ fn: escaping Fn){ gFn fn }//fn是逃逸闭包 //当将 fn 赋值给 gFn 时fn 仍然能够被访问和调用即使 test2 函数已经返回。这种情况下闭包逃脱了函数的作用域。 func test3(_ fn: escaping Fn){ DispatchQueue.global().async { //这个也是逃逸闭包 fn() } } class Personq { var fn: Fn //Fn是逃逸闭包 init(fn: escaping Fn) { self.fn fn } func run(){ DispatchQueue.global().async {//这也是一个逃逸闭包同时用到了实例成员(var的部分)编译器会强制要求写出self self.fn() } } } //逃逸闭包注意点逃逸闭包不可以捕获inout参数 /* typealias Fn2 () - () func other1(_ fn: Fn2){fn()} func other2(_ fn: escaping Fn2){ fn() } func test(value: inout Int) - Fn { other1 { value 1 } //这里会出错因为逃逸闭包不能捕获inout参数 other2{ value 1 } //这里也是 func plus() {value 1 } return plus } */ //内存访问冲突(Conflicting Access to Memory) //内存访问冲突会在两个访问满足下列条件的时候发生 //1.至少一个是写入操作 //2.它们访问的是同一块内存 //3.它们的访问时间重叠如在同一个函数内 //↓这是没冲突的情况 func plus(_ num: inout Int) - Int { num 1 } var number 1 //↓存在内存访问冲突 /* var step 1 func increment(_ num: inout Int) {num step } increment(step) //当调用 increment(step) 时编译器需要同时访问step变量来读取和修改它的值。这意味着在调用increment 时程序需要对step进行排他性访问但因为num也是step的引用导致函数内对num的修改尝试与外部对step的访问冲突。 //解决内存访问冲突 var copy0Step step //通过给step创建一个副本(copy0Step)的方式可以避免内存访问冲突。 increment(copy0Step) step copy0Step */ //内存访问冲突 func balance(_ x: inout Int, _ y: inout Int) { let sum x y x sum / 2 y sum - x } var num1 42 var num2 30 balance(num1, num2) //可以运行 //balance(num1, num1) //不可以运行因为同时访问了同一块内存(在player) var oscar Player(name: Oscar, health: 10, energy: 10) var maria Player(name: Maria, health: 5, energy: 10) oscar.shareHealth(with: maria) //可以运行 //oscar.shareHealth(with: oscar)//不可以运行因为同时调用了两次oscar var tulpe (health: 10, energy: 20) //balance(tulpe.health, tulpe.energy) //运行会出错我也不知道为什么 //var holly Player(name: Holly, health: 10, energy: 10) //不可以运行因为同时调用了两次 //balance(holly.health, holly.energy)会报错内存访问冲突 //(复习)存储属性、计算属性、类属性 //1.存储属性是用于存储类或结构体实例的常量或变量。每个实例都有自己的属性值。可以是变量var或常量let。 //2.计算属性不会直接存储值而是通过计算得到其值。计算属性可以带有 getter 和可选的 setter。 //3.类属性是与类本身相关而不是与类的实例相关的属性。可以是存储属性或计算属性使用 static关键字定义适用于类和结构体使用 class 关键字定义适用于类允许子类重写。 //内存访问冲突如果下面的条件可以满足就说明【重叠访问结构体的属性是安全的】 //1.你只访问实例存储属性不是计算属性或者类属性 //2.结构体是局部变量而非全局变量 //3.结构体没有被闭包捕获/结构体只被逃逸闭包捕获 func test999() { var tulpe (health: 10, energy: 20) balance(tulpe.health, tulpe.energy) var silverwolf Player(name: Silverwolf, health: 999, energy: 999) balance(silverwolf.health, silverwolf.energy)//只访问存储属性 } test999() //指针类型用于直接操作存储在内存中的值提供了一种直接访问内存的机制。这类指针一般分为以下几种类型并被标记为“不安全Unsafe”因为错误的使用可能导致内存泄漏、数据损坏或无法预料的崩溃。 //1.UnsafePointerPointee用于指向常量类型的指针,类似const Pointee * //2.UnsafeMutablePointer用于指向可变类型的指针,类似 Pointee * //3.UnsafeRawPointer不具有类型安全性指向原始的内存位置,类似const void * //4.UnsafeMutableRawPointer用于指向可以被修改的原始内存位置,类似void * /*为什么不安全 指针的“不安全”属性主要体现在以下几个方面 内存管理 使用指针时你需要手动管理内存如果错误地分配或释放内存会导致内存泄漏或应用崩溃。 类型安全 指针不强制检查类型开发者必须小心使用以确保对应的类型匹配。错误的类型访问会导致运行时错误。 数据竞争 多线程环境中多个线程同时访问和修改同一块内存可能会引发数据竞争问题从而导致不可预知的行为。 垃圾回收失效 Swift 的内存管理通过 ARC自动引用计数来处置内存但使用指针时可能会绕过 ARC从而不能正确跟踪内存的生命周期。 */ var age 10 func test123(_ ptr: UnsafeMutablePointerInt) { ptr.pointee 10 } func test456(_ ptr: UnsafePointerInt) { print(ptr.pointee) } test123(age) test456(age)//20 print(age)//20 func test999(_ ptr: UnsafeMutableRawPointer) { ptr.storeBytes(of: 20, as: Int.self) } func test1000(_ ptr: UnsafeRawPointer) { print(ptr.load(as: Int.self)) } test999(age) test1000(age)//20 print(age)//20 //指针的应用示例 var arr NSArray (objects: 11, 22, 33, 44) arr.enumerateObjects { (obj, idx, stop) in print(idx, obj) if idx 2 {//下标为2就停止遍历 stop.pointee true } } for (idx, obj)in arr.enumerated() { print(idx, obj) if idx 2 { break } } //NSArray 是 OC 中的一个类。 //主要特性1.不可变一旦创建NSArray 的内容无法更改。如果需要可变数组可以使用 NSMutableArray。 //2.存储类型可以存储任何对象NSString、NSNumber、NSDate等但不能存储原始数据类型如 Int直接必须通过封装。 //NSString、NSNumber 和 NSDate 是 Objective-C 中的基本类分别用于处理字符串、数字和日期。这些类在 Cocoa 和 Cocoa Touch 框架中广泛使用并且在 Swift 中也可以使用。 //获得指向某个变量的指针:其实我看不懂 var age11 11 var ptr1 withUnsafeMutablePointer(to: age11) { $0 } //$ 可以用于字符串插值使得在字符串模板中嵌入变量更加方便。 var pte2 withUnsafePointer(to: age11) { $0 } ptr1.pointee 22 print(pte2.pointee) //22 print(age11)//22 var ptr3 withUnsafeMutablePointer(to: age11){ UnsafeMutableRawPointer($0)} var ptr4 withUnsafePointer(to: age11) { UnsafeRawPointer ($0)} ptr3.storeBytes(of: 33, as: Int.self) print(ptr4.load(as: Int.self)) //33 print(age11)//33 //获得指向堆空间实例的指针 class Persone {} var person Persone() var ptr withUnsafePointer(to: person) { UnsafeRawPointer($0) } var heapPtr UnsafeRawPointer(bitPattern: ptr.load(as: UInt.self)) print(heapPtr!)//0x00000001008967f0 //创建指针 var ptr11 UnsafeRawPointer(bitPattern: 0x100001234) var ptr2 malloc(16)//创建 ptr2?.storeBytes(of: 11, as: Int.self) ptr2?.storeBytes(of: 22, toByteOffset: 8, as: Int.self)//存 print((ptr2?.load(as: Int.self))!)//11 print((ptr2?.load(fromByteOffset: 8, as: Int.self))!)//22 free(ptr2) //销毁 var ptr5 UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1) ptr5.storeBytes(of: 11, as: Int.self) print(ptr5.load(as: Int.self))//11 print(ptr5.advanced(by: 8).load(as: Int.self))//0 可能是因为没有正确地存储值或者间接地访问了一个未初始化的内存区域搞不懂答案是22但是我这里输出的是0 ptr5.deallocate() //创建指针 var ptr123 UnsafeMutablePointerInt.allocate(capacity: 3) ptr123.initialize(to: 11) ptr123.successor().initialize(to: 22) ptr123.successor().successor().initialize(to: 33) print(ptr123.pointee)//11 print((ptr123 1).pointee)//22 print((ptr123 2).pointee)//33 print(ptr123[0])//11 print(ptr123[1])//22 print(ptr123[2])//33 ptr123.deinitialize(count: 3) ptr123.deallocate() //创建指针2见Personp类 var ptrp UnsafeMutablePointerPersonp.allocate(capacity: 3) ptrp.initialize(to: Personp(age: 10, name: Cipher)) (ptrp 1).initialize(to: Personp(age:11, name: Aglaea)) (ptrp 2).initialize(to: Personp(age:12, name: Anaxa)) ptrp.deinitialize(count: 3) ptrp.deallocate() //指针之间的转换 var ptrm UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1) ptrm.assumingMemoryBound(to: Int.self).pointee 11 (ptrm 8).assumingMemoryBound(to: Double.self).pointee 22.0 print(unsafeBitCast(ptrm, to: UnsafePointerInt.self).pointee) //11 print(unsafeBitCast(ptrm 8, to: UnsafePointerDouble.self).pointee)//22.0 ptrm.deallocate() //unsafeBitCast是忽略数据类型的强制转换不会因为数据类型的变化而改变原来的内存数据(类似C中的reinterpart_cast) class Person111 {} var person111 Person111() var ptr111 unsafeBitCast(person111, to: UnsafeRawPointer.self) print(ptr111) //其实这部分都不是很懂。。。。