Swift-自动引用计数，工作机制、强引用、弱引用

最新推荐文章于 2021-10-13 20:00:45 发布
最新推荐文章于 2021-10-13 20:00:45 发布
阅读量163 收藏
点赞数
分类专栏： Swift语法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DevXue/article/details/104893907
版权
  • Swift 使用自动引用计数（ARC）机制来跟踪和管理你的应用程序的内存。
  • 通常情况下，Swift 内存管理机制会一直起作用，你无须自己来考虑内存的管理。
  • ARC 会在类的实例不再被使用时，自动释放其占用的内存。

注意：

  1. 引用计数仅仅应用于类的实例。
  2. 结构体和枚举类型是值类型，不是引用类型，也不是通过引用的方式存储和传递。

1. 自动引用计数的工作机制

  • 当你每次创建一个类的新的实例的时候，ARC 会分配一块内存来储存该实例信息。内存中会包含实例的类型信息，以及这个实例所有相关的存储型属性的值。
  • 此外，当实例不再被使用时，ARC 释放实例所占用的内存，并让释放的内存能挪作他用。这确保了不再被使用的实例，不会一直占用内存空间。
  • 然而，当 ARC 收回和释放了正在被使用中的实例，该实例的属性和方法将不能再被访问和调用。实际上，如果你试图访问这个实例，你的应用程序很可能会崩溃。
  • 为了确保使用中的实例不会被销毁，ARC 会跟踪和计算每一个实例正在被多少属性，常量和变量所引用。哪怕实例的引用数为 1，ARC 都不会销毁这个实例。
  • 为了使上述成为可能，无论你将实例赋值给属性、常量或变量，它们都会创建此实例的强引用。之所以称之为“强”引用，是因为它会将实例牢牢地保持住，只要强引用还在，实例是不允许被销毁的。

2. 自动引用计数实践

下面的例子展示了自动引用计数的工作机制。例子以一个简单的 Person 类开始，并定义了一个叫 name 的常量属性：

class Person {
    let name: String
    init(name: String) {    //  此构造器为实例的 name 属性赋值，并打印一条消息以表明初始化过程生效。
        self.name = name
        print("\(name) is being initialized")
    }
    deinit {    //  Person 类也拥有一个析构器，这个析构器会在实例被销毁时打印一条消息。
        print("\(name) is being deinitialized")
    }
}
  • 接下来为新的 Person 实例建立多个引用。由于这些变量是被定义为可选类型（Person?，而不是 Person），它们的值会被自动初始化为 nil，目前还不会引用到 Person 类的实例。
var reference1: Person?
var reference2: Person?
var reference3: Person?

reference1 = Person(name: "John Appleseed")
// 打印“John Appleseed is being initialized”

应当注意到当你调用 Person 类的构造器的时候，"John Appleseed is being initialized" 会被打印出来。由此可以确定构造器被执行。
由于 Person 类的新实例被赋值给了 reference1 变量，所以 reference1 到 Person 类的新实例之间建立了一个强引用。
正是因为这一个强引用，ARC 会保证 Person 实例被保持在内存中不被销毁。

  • 如果你将同一个 Person 实例也赋值给其他两个变量，该实例又会多出两个强引用：
reference2 = reference1
reference3 = reference1
  • 现在这一个 Person 实例已经有三个强引用了。
  • 通过给其中两个变量赋值 nil 的方式断开两个强引用（包括最先的那个强引用），只留下一个强引用，Person 实例不会被销毁：
    reference1 = nil
    reference2 = nil
  • 第三个也就是最后一个强引用被断开时，ARC 会销毁它：
    reference3 = nil
    // 打印“John Appleseed is being deinitialized”

3. 类实例之间的循环强引用

  • 如果两个类实例互相持有对方的强引用，因而每个实例都让对方一直存在，就是这种情况。这就是所谓的循环强引用。
  • 你可以通过定义类之间的关系为弱引用或无主引用，以替代强引用，从而解决循环强引用的问题。
  • 下面展示了一个不经意产生循环强引用的例子。例子定义了两个类：Person 和 Apartment，用来建模公寓和它其中的居民：
    class Person {
        let name: String
        init(name: String) { self.name = name }
        var apartment: Apartment?
        deinit { print("\(name) is being deinitialized") }
    }
    
    class Apartment {
        let unit: String
        init(unit: String) { self.unit = unit }
        var tenant: Person?
        deinit { print("Apartment \(unit) is being deinitialized") }
    }

两个类都定义了析构器，用以在类实例被析构的时候输出信息。这让你能够知晓 Person 和 Apartment 的实例是否像预期的那样被销毁。

  • 接下来的代码片段定义了两个可选类型的变量 john 和 unit4A，并分别被设定为下面的 Apartment 和 Person 的实例。这两个变量都被初始化为 nil，这正是可选类型的优点：
var john: Person?
var unit4A: Apartment?
john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")
  • 现在你能够将这两个实例关联在一起，这样人就能有公寓住了，而公寓也有了房客。注意感叹号是用来展开和访问可选变量 john 和 unit4A 中的实例，这样实例的属性才能被赋值：
    john!.apartment = unit4A
    unit4A!.tenant = john
  • 不幸的是，这两个实例关联后会产生一个循环强引用。
  • Person 实例现在有了一个指向 Apartment 实例的强引用，而 Apartment 实例也有了一个指向 Person 实例的强引用。
  • 因此，当你断开 john 和 unit4A 变量所持有的强引用时，引用计数并不会降为 0，实例也不会被 ARC 销毁：
john = nil
unit4A = nil

注意，当你把这两个变量设为 nil 时，没有任何一个析构器被调用。循环强引用会一直阻止 Person 和 Apartment 类实例的销毁，这就在你的应用程序中造成了内存泄漏。

Person 和 Apartment 实例之间的强引用关系保留了下来并且不会被断开。

4. 解决实例之间的循环强引用

  • Swift 提供了两种办法用来解决你在使用类的属性时所遇到的循环强引用问题：
    • 弱引用（weak reference）
    • 无主引用（unowned reference）。
  • 弱引用和无主引用允许循环引用中的一个实例引用另一个实例而不保持强引用。这样实例能够互相引用而不产生循环强引用。
  • 当其他的实例有更短的生命周期时，使用弱引用，也就是说，当其他实例析构在先时。
  • 在上面公寓的例子中，很显然一个公寓在它的生命周期内会在某个时间段没有它的主人，所以一个弱引用就加在公寓类里面，避免循环引用。相比之下，当其他实例有相同的或者更长生命周期时，请使用无主引用。

4.1 弱引用

  • 弱引用不会对其引用的实例保持强引用，因而不会阻止 ARC 销毁被引用的实例。
  • 这个特性阻止了引用变为循环强引用。
  • 声明属性或者变量时，在前面加上 weak 关键字表明这是一个弱引用。
  • 因为弱引用不会保持所引用的实例，即使引用存在，实例也有可能被销毁。
  • 因此，ARC 会在引用的实例被销毁后自动将其弱引用赋值为 nil。
  • 并且因为弱引用需要在运行时允许被赋值为 nil，所以它们会被定义为可选类型变量，而不是常量。
  • 你可以像其他可选值一样，检查弱引用的值是否存在，你将永远不会访问已销毁的实例的引用。

注意

当 ARC 设置弱引用为 nil 时，属性观察不会被触发。

  • 下面的例子跟上面 Person 和 Apartment 的例子一致，但是有一个重要的区别。这一次，Apartment 的 tenant 属性被声明为弱引用：
class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { print("\(name) is being deinitialized") }
}

class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    weak var tenant: Person?
    deinit { print("Apartment \(unit) is being deinitialized") }
}

var john: Person?
var unit4A: Apartment?

john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")

john!.apartment = unit4A
unit4A!.tenant = john

/*
Person 实例依然保持对 Apartment 实例的强引用，但是 Apartment 实例只持有对 Person 实例的弱引用。
这意味着当你通过把 john 变量赋值为 nil 而断开其所保持的强引用时，再也没有指向 Person 实例的强引用了。
*/
john = nil  //  由于再也没有指向 Person 实例的强引用，该实例会被销毁，且 tenant 属性会被赋值为 nil
// 打印“John Appleseed is being deinitialized”

/*
唯一剩下的指向 Apartment 实例的强引用来自于变量 unit4A。
如果你断开这个强引用，再也没有指向 Apartment 实例的强引用了
*/
unit4A = nil    //  由于再也没有指向 Person 实例的强引用，该实例会被销毁
// 打印“Apartment 4A is being deinitialized”

注意
    1. 在使用垃圾收集的系统里，弱指针有时用来实现简单的缓冲机制，因为没有强引用的对象只会在内存压力触发垃圾收集时才被销毁。
    2. 但是在 ARC 中，一旦值的最后一个强引用被移除，就会被立即销毁，这导致弱引用并不适合上面的用途。

4.2 无主引用

  • 和弱引用类似，无主引用不会牢牢保持住引用的实例。
  • 和弱引用不同的是，无主引用在其他实例有相同或者更长的生命周期时使用。
  • 你可以在声明属性或者变量时，在前面加上关键字 unowned 表示这是一个无主引用。
  • 无主引用通常都被期望拥有值。不过 ARC 无法在实例被销毁后将无主引用设为 nil，因为非可选类型的变量不允许被赋值为 nil。

重点

  1. 使用无主引用，你必须确保引用始终指向一个未销毁的实例。
  2. 如果你试图在实例被销毁后，访问该实例的无主引用，会触发运行时错误。

下面的例子定义了两个类，Customer 和 CreditCard，模拟了银行客户和客户的信用卡。这两个类中，每一个都将另外一个类的实例作为自身的属性。这种关系可能会造成循环强引用。
Customer 和 CreditCard 之间的关系与前面弱引用例子中 Apartment 和 Person 的关系略微不同。在这个数据模型中，一个客户可能有或者没有信用卡，但是一张信用卡总是关联着一个客户。为了表示这种关系，Customer 类有一个可选类型的 card 属性，但是 CreditCard 类有一个非可选类型的 customer 属性。
此外，只能通过将一个 number 值和 customer 实例传递给 CreditCard 构造器的方式来创建 CreditCard 实例。这样可以确保当创建 CreditCard 实例时总是有一个 customer 实例与之关联。

  • 由于信用卡总是关联着一个客户，因此将 customer 属性定义为无主引用，用以避免循环强引用：
class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) {
        self.name = name
    }
    deinit { print("\(name) is being deinitialized") }
}

class CreditCard {
    let number: UInt64
    unowned let customer: Customer
    init(number: UInt64, customer: Customer) {  //  CreditCard 类的 number 属性被定义为 UInt64 类型而不是 Int 类型，以确保 number 属性的存储量在 32 位和 64 位系统上都能足够容纳 16 位的卡号。
        self.number = number
        self.customer = customer
    }
    deinit { print("Card #\(number) is being deinitialized") }
}

/*
定义了一个叫 john 的可选类型 Customer 变量
用来保存某个特定客户的引用
由于是可选类型，所以变量被初始化为 nil
*/
var john: Customer?

john = Customer(name: "John Appleseed")
john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)

/*
Customer 实例持有对 CreditCard 实例的强引用
而 CreditCard 实例持有对 Customer 实例的无主引用
由于 customer 的无主引用，当你断开 john 变量持有的强引用时，再也没有指向 Customer 实例的强引用了
由于再也没有指向 Customer 实例的强引用，该实例被销毁了。
其后，再也没有指向 CreditCard 实例的强引用，该实例也随之被销毁了：
*/
john = nil  //   john 变量被设为 nil 后 Customer 实例和 CreditCard 实例的析构器都打印出了“销毁”的信息。
// 打印“John Appleseed is being deinitialized”
// 打印“Card #1234567890123456 is being deinitialized”


注意
    1. 上面的例子展示了如何使用安全的无主引用。
    2. 对于需要禁用运行时的安全检查的情况（例如，出于性能方面的原因），Swift 还提供了不安全的无主引用。
    3. 与所有不安全的操作一样，你需要负责检查代码以确保其安全性。
    4.  你可以通过 unowned(unsafe) 来声明不安全无主引用。
    5. 如果你试图在实例被销毁后，访问该实例的不安全无主引用，你的程序会尝试访问该实例之前所在的内存地址，这是一个不安全的操作。

4.3 无主引用和隐式解包可选值属性

  • 上面弱引用和无主引用的例子涵盖了两种常用的需要打破循环强引用的场景。
    • Person 和 Apartment 的例子展示了两个属性的值都允许为 nil，并会潜在的产生循环强引用。这种场景最适合用弱引用来解决。
    • Customer 和 CreditCard 的例子展示了一个属性的值允许为 nil，而另一个属性的值不允许为 nil，这也可能会产生循环强引用。这种场景最适合通过无主引用来解决。
  • 然而，存在着第三种场景，在这种场景中，两个属性都必须有值，并且初始化完成后永远不会为 nil。在这种场景中，需要一个类使用无主属性，而另外一个类使用隐式解包可选值属性。
  • 这使两个属性在初始化完成后能被直接访问（不需要可选展开），同时避免了循环引用。
  • 下面的例子定义了两个类：
/*
Country 和 City
每个类将另外一个类的实例保存为属性
在这个模型中，每个国家必须有首都
每个城市必须属于一个国家
为了实现这种关系，Country 类拥有一个 capitalCity 属性
而 City 类有一个 country 属性
*/
class Country {
    let name: String
    /*
    通过在类型结尾处加上感叹号（City!）的方式
    将 Country 的 capitalCity 属性声明为隐式解包可选值类型的属性
    这意味着像其他可选类型一样，capitalCity 属性的默认值为 nil，但是不需要展开它的值就能访问它。
    */
    var capitalCity: City!  
    init(name: String, capitalName: String) {
        self.name = name
        /*
        由于 capitalCity 默认值为 nil
        一旦 Country 的实例在构造器中给 name 属性赋值后，整个初始化过程就完成了。
        这意味着一旦 name 属性被赋值后，Country 的构造器就能引用并传递隐式的 self。
        Country 的构造器在赋值 capitalCity 时，就能将 self 作为参数传递给 City 的构造器。
        */
        self.capitalCity = City(name: capitalName, country: self)   //  Country 的构造器调用了 City 的构造器。然而，只有 Country 的实例完全初始化后，Country 的构造器才能把 self 传给 City 的构造器。
    }
}

class City {
    let name: String
    unowned let country: Country
    init(name: String, country: Country) {
        self.name = name
        self.country = country
    }
}

/*
以上的意义在于你可以通过一条语句同时创建 Country 和 City 的实例，而不产生循环强引用
并且 capitalCity 的属性能被直接访问，而不需要通过感叹号来展开它的可选值
*/
var country = Country(name: "Canada", capitalName: "Ottawa")
print("\(country.name)'s capital city is called \(country.capitalCity.name)")
// 打印“Canada's capital city is called Ottawa”

在上面的例子中，使用隐式解包可选值值意味着满足了类的构造器的两个构造阶段的要求。
capitalCity 属性在初始化完成后，能像非可选值一样使用和存取，同时还避免了循环强引用。

5. 闭包的循环强引用

  • 循环强引用还会发生在当你将一个闭包赋值给类实例的某个属性，并且这个闭包体中又使用了这个类实例时。
  • 这个闭包体中可能访问了实例的某个属性
    • 例如 self.someProperty，或者闭包中调用了实例的某个方法
    • 例如 self.someMethod()。这两种情况都导致了闭包“捕获”self，从而产生了循环强引用。
  • 循环强引用的产生，是因为闭包和类相似，都是引用类型。
  • 当你把一个闭包赋值给某个属性时，你是将这个闭包的引用赋值给了属性。
  • 实质上，这跟之前的问题是一样的——两个强引用让彼此一直有效。
  • 但是，和两个类实例不同，这次一个是类实例，另一个是闭包。
  • Swift 提供了一种优雅的方法来解决这个问题，称之为 闭包捕获列表（closure capture list）。
  • 下面的例子为你展示了当一个闭包引用了 self 后是如何产生一个循环强引用的。例子中定义了一个叫 HTMLElement 的类，用一种简单的模型表示 HTML 文档中的一个单独的元素：
class HTMLElement {

    let name: String
    let text: String?
    /*
    定义了一个 lazy 属性 asHTML
    这个属性引用了一个将 name 和 text 组合成 HTML 字符串片段的闭包
    该属性是 Void -> String 类型
    或者可以理解为“一个没有参数，返回 String 的函数”。

    闭包赋值给了 asHTML 属性，这个闭包返回一个代表 HTML 标签的字符串
    如果 text 值存在，该标签就包含可选值 text
    如果 text 不存在，该标签就不包含文本
    对于段落元素，根据 text 是 "some text" 还是 nil，闭包会返回 "<p>some text</p>" 或者 "<p />"。

    asHTML 声明为 lazy 属性
    因为只有当元素确实需要被处理为 HTML 输出的字符串时，才需要使用 asHTML
    也就是说，在默认的闭包中可以使用 self，因为只有当初始化完成以及 self 确实存在后，才能访问 lazy 属性。
    */
    lazy var asHTML: () -> String = {
        /*
        实例的 asHTML 属性持有闭包的强引用
        但是，闭包在其闭包体内使用了 self（引用了 self.name 和 self.text）
        因此闭包捕获了 self，这意味着闭包又反过来持有了 HTMLElement 实例的强引用。这样两个对象就产生了循环强引用。
        */
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }

    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }

    deinit {
        print("\(name) is being deinitialized")
    }
}

/*
将一个闭包赋值给 asHTML 属性
这个闭包能在 text 属性是 nil 时使用默认文本
这是为了避免返回一个空的 HTML 标签
*/
let heading = HTMLElement(name: "h1")
let defaultText = "some default text"
heading.asHTML = {
    return "<\(heading.name)>\(heading.text ?? defaultText)</\(heading.name)>"
}
print(heading.asHTML()) // 打印“<h1>some default text</h1>”

//  用 HTMLElement 类创建实例并打印消息：
var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())
// 打印“<p>hello, world</p>”

//  paragraph 变量为 nil，打破它持有的 HTMLElement 实例的强引用，HTMLElement 实例和它的闭包都不会被销毁，也是因为循环强引用
paragraph = nil //  HTMLElement 的析构器中的消息并没有被打印，证明了 HTMLElement 实例并没有被销毁。

6. 解决闭包的循环强引用

  • 在定义闭包时同时定义捕获列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用。
  • 捕获列表定义了闭包体内捕获一个或者多个引用类型的规则。
  • 跟解决两个类实例间的循环强引用一样，声明每个捕获的引用为弱引用或无主引用，而不是强引用。
  • 根据代码关系来决定使用弱引用还是无主引用。

注意
Swift 有如下要求：只要在闭包内使用 self 的成员，就要用 self.someProperty 或者 self.someMethod()（而不只是 someProperty 或 someMethod()）。
这提醒你可能会一不小心就捕获了 self。

6.1 定义捕获列表

  • 捕获列表中的每一项都由一对元素组成
    • 一个元素是 weak 或 unowned 关键字
    • 另一个元素是类实例的引用（例如 self）或初始化过的变量（如 delegate = self.delegate!）。
  • 这些项在方括号中用逗号分开。
  • 如果闭包有参数列表和返回类型，把捕获列表放在它们前面：
lazy var someClosure: (Int, String) -> String = {
    [unowned self, weak delegate = self.delegate!] (index: Int, stringToProcess: String) -> String in
    // 这里是闭包的函数体
}
  • 如果闭包没有指明参数列表或者返回类型，它们会通过上下文推断，那么可以把捕获列表和关键字 in 放在闭包最开始的地方：
lazy var someClosure: () -> String = {
    [unowned self, weak delegate = self.delegate!] in
    // 这里是闭包的函数体
}

6.2 弱引用和无主引用

  • 在闭包和捕获的实例总是互相引用并且总是同时销毁时，将闭包内的捕获定义为 无主引用。
  • 相反的，在被捕获的引用可能会变为 nil 时，将闭包内的捕获定义为 弱引用。
  • 弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为 nil。这使我们可以在闭包体内检查它们是否存在。
  • 注意
    • 如果被捕获的引用绝对不会变为 nil，应该用无主引用，而不是弱引用。
    • 前面的 HTMLElement 例子中，无主引用是正确的解决循环强引用的方法。
  • 这样编写 HTMLElement 类来避免循环强引用：
class HTMLElement {

    let name: String
    let text: String?

    lazy var asHTML: () -> String = {
        /*
        asHTML 闭包中多了一个捕获列表: [unowned self]
        表示“将 self 捕获为无主引用而不是强引用”。
        */
        [unowned self] in
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }

    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }

    deinit {
        print("\(name) is being deinitialized")
    }
}

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())  // 打印“<p>hello, world</p>”

/* 
如果将 paragraph 赋值为 nil
HTMLElement 实例将会被销毁，并能看到它的析构器打印出的消息：
*/
paragraph = nil
// 打印“p is being deinitialized”

这一次，闭包以无主引用的形式捕获 self，并不会持有 HTMLElement 实例的强引用。

dev.xue
关注
专栏目录
Swift闭包里强弱引用的那些陷阱和奥秘
享受开发，颠倒银河
01-12 1199
在本篇博文中，您将学到以下内容： - 为什么要在闭包中加上[weak self] 和[unowned self]？它们有什么区别？ - 是不是闭包中总是要加上[weak self]？ - 在闭包中除了用[weak/unowned self] 还有其它消除引用循环的方法吗？ - 在闭包中强引用对象的两种方法。 - 不会造成循环引用的值类型在闭包中使用真的是人畜无害吗？
swift 弱引用_Swift中解释的弱引用和无主引用之间的区别
weixin_26638123的博客
08-27 887
swift 弱引用It’s a good practice to know how memory management works in Swift. Swift uses Automatic Reference Counting (ARC) to manage the app’s memory automatically without writing any additional code. ...
Swift-自动引用计数
hkasdfiu12
08-13 149
Swift 使用自动引用计数（ARC）机制来跟踪和管理你的应用程序的内存。 通常情况下，Swift 内存管理机制会一直起作用，你无须自己来考虑内存的管理。 ARC 会在类的实例不再被使用时，自动释放其占用的内存。 注意： 引用计数仅仅应用于类的实例。 结构体和枚举类型是值类型，不是引用类型，也不是通过引用的方式存储和传递。 1. 自动引用计数的工作机制 当你每次创建一个类的新的实例的...
Swift_ARC自动引用计数(强引用和弱引用)
爱技术....爱生活！
08-08 557
Jason类里面为 weak 弱引用  ROUSI类(可以避免循环强引用) class Jason { var name:String? init(name:String) { print("Jason 实例化") self.name = name } weak var rousi:ROUSI? deinit {
Swift入门（十）——循环引用、弱引用和无主引用
KT的iOS开发小站
08-23 7083
最近看到swift里面不仅有循环引用和弱引用（weak），还添加了无主引用（unowned），于是写了一些demo，这里总结一下。和OC一样，Swfit默认也是基于ARC进行内存管理的，因此虽然简单，但如果不注意任然会出现循环引用问题（Retain cycle），导致内存泄露。在OC中，可以很简单的举出一个循环引用的例子。比如有两个类A和B，A中有一个属性是B类的实例，而B中又有一个属性是A类的实例
Swift learning part 23 - 自动引用计数
毛毛虫
08-06 1459
文章目录自动引用计数的工作机制自动引用计数实践类实例之间的循环强引用解决实例之间的循环强引用弱引用无主引用无主引用和隐式解包可选值属性闭包的循环强引用解决闭包的循环强引用定义捕获列表弱引用和无主引用 Swift 使用自动引用计数（ARC）机制来跟踪和管理你的应用程序的内存。通常情况下，Swift 内存管理机制会一直起作用，你无须自己来考虑内存的管理。然而在少数情况下，为了能帮助你管理内存，ARC ...
深入剖析 Swift 中的自动引用计数（ARC）机制
最新发布
09-10
理解 ARC 的工作原理和正确使用强引用、弱引用和无主引用对于编写高效、稳定且可靠的 Swift 程序至关重要。通过避免循环引用和正确管理闭包中的引用，可以充分利用 ARC 的优势，确保应用程序的性能和稳定性。 在 ...
Swift 自动引用计数（ARC）.pdf
02-20
### Swift自动引用计数（ARC） Swift是一种现代且高效的编程语言，主要应用于iOS、macOS、watchOS和tvOS等Apple平台的开发。Swift引入了许多先进的功能和改进，旨在提高程序的安全性和性能，同时简化了代码编写过程...
Swift中的自动引用计数：释放内存的艺术
07-22
在Swift编程语言中，自动引用计数（Automatic Reference Counting，简称ARC）是一种强大的内存管理机制，它极大简化了内存管理的复杂度，使开发者能够更加专注于应用程序的核心功能实现。下面我们将深入探讨Swift中...
Swift里自动引用计数
10-13 343
自动引用计数（ARC） Swift 使用自动引用计数（ARC）机制来跟踪和管理你的应用程序的内存。ARC 会在类的实例不再被使用时，自动释放其占用的内存Swift 使用 ARC 与在 Obejctive-C 中使用 ARC 非常类似 自动引用计数的工作机制（引用计数器为0时才释放对象 ARC 回收并释放了正在被使用中的实例后，该实例的属性和方法将不能再被访问和调用。如果试图访问这个实例，你的应用程序很可能会崩溃。 为了确保使用中的实例不会被销毁，ARC 会跟踪和计算每一个实例正在被多少属性，常量和.
详谈swift内存管理中的引用计数
08-29
总结一下，Swift的引用计数是通过ARC自动管理内存的重要机制，它确保了对象在不再使用时能够被正确释放。了解并熟练掌握引用计数的概念和实践，对于编写高效、稳定的Swift代码至关重要。在编写涉及对象生命周期的...
swift 弱引用_在Swift中何时在弱引用上使用强引用
weixin_26638123的博客
07-24 610
swift 弱引用 总览 (Overview) If we talk about memory leaks, the first thing we rush to check is the retain cycle. To avoid this scenario we declare properties or capture self as weak. 如果我们谈论内存泄漏，我们首先要检查的是保...
Swift-枚举，枚举值匹配、遍历、关联值、原始值递归枚举
DevXue的博客
11-11 1569
Swift 中的枚举，不必给每一个枚举成员提供一个值。 如果给枚举成员提供一个值（称为原始值），则该值的类型可以是字符串、字符，或是一个整型值或浮点数。 1. 枚举语法 使用 enum 关键词来创建枚举并且把它们的整个定义放在一对大括号内： enum SomeEnumeration { // 枚举定义放在这里 } 使用 case 关键字来定义一个新的枚举成员值： ...
Swift-闭包，隐式返回、尾随闭包、值捕获、逃逸闭包、自动闭包
DevXue的博客
11-10 1036
闭包 闭包可以捕获和存储其所在上下文中任意常量和变量的引用，被称为包裹常量和变量。 Swift 会为你管理在捕获过程中涉及到的所有内存操作。 全局和嵌套函数实际上也是特殊的闭包，闭包采用如下三种形式之一： 全局函数是一个有名字但不会捕获任何值的闭包。 嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包。 闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿...
Swift-泛型，类型参数、类型参数，泛型函数、类型、扩展、约束，关联类型
DevXue的博客
11-10 707
泛型代码让你能根据自定义的需求，编写出适用于任意类型的、灵活可复用的函数及类型。 你可避免编写重复的代码，而是用一种清晰抽象的方式来表达代码的意图。 1. 泛型解决的问题 下面是一个标准的非泛型函数 swapTwoInts(::)，用来交换两个 Int 值： func swapTwoInts(_ a: inout Int, _ b: inout Int) { // 这个...
Swift-属性，存储属性（var、let）、计算属性（getter、setter）、属性观察器、全局变量和局部变量
DevXue的博客
11-10 531
1. 存储属性 一个存储属性就是存储在特定类或结构体实例里的一个常量或变量。 可以是变量存储属性（用关键字 var 定义）。 也可以是常量存储属性（用关键字 let 定义）。 struct FixedLengthRange { var firstValue: Int let length: Int } var rangeOfThreeItems = FixedL...
Swift-函数，定义、调用、返回值、参数、隐式返回、可变参数、嵌套函数
DevXue的博客
11-09 531
1. 函数的定义与调用 以 func 作为前缀。 函数返回类型： ->（一个连字符后跟一个右尖括号）后跟返回类型的名称的方式来表示。 func greet(person: String) -> String { // 函数的名字是 greet(person:) let greeting = "Hello, " + person + "!" ret...
Swift-字符串和字符，可变性、连接、插值、计算、索引、删除、比较、前缀、后缀
DevXue的博客
11-10 378
1. 字符串 在 Swift 中 String 类型是值类型。 如果你创建了一个新的字符串，那么当其进行常量、变量赋值操作，或在函数/方法中传递时，会进行值拷贝。 在前述任一情况下，都会对已有字符串值创建新副本，并对该新副本而非原始字符串进行传递或赋值操作 1.1 初始化空字符串 // 两个字符串均为空并等价。 var emptyString = "" // 空字符串字...
Swift-高级运算符，位运算符、溢出运算符、优先级和结合性、运算符函数
DevXue的博客
11-09 356
与 C 语言中的算术运算符不同，Swift 中的算术运算符默认是不会溢出的。 所有溢出行为都会被捕获并报告为错误。 如果想让系统允许溢出行为，可以选择使用 Swift 中另一套默认支持溢出的运算符，比如溢出加法运算符（&+）。 所有的这些溢出运算符都是以 & 开头的。 1. 位运算符 位运算符可以操作数据结构中每个独立的比特位。 它们通常被用在底层开发中，比如...
深入解析Swift的自动引用计数（ARC）机制
资源摘要信息: "Swift中的自动引用计数（ARC）是如何工作的？" Swift语言作为苹果公司推出的一种现代编程语言，以其类型安全、现代语法、高性能、内存安全以及与其他苹果平台语言的互操作性等特性，成为开发iOS等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值