彻底搞懂Swift类与结构体：iOS开发内存优化实战指南
项目地址: https://gitcode.com/gh_mirrors/sw/swift-summary 引言：为什么90%的Swift开发者都用错了类与结构体？
你是否曾在Swift开发中遇到这样的困惑：明明功能相同的代码，用类实现会导致内存泄漏，用结构体却运行流畅？当你在ViewController中声明一个属性时，究竟该用class还是struct？为什么Apple官方文档强调"优先使用结构体"却在UIKit中全是类？
本文将通过30+代码示例、5个对比表格和3组流程图，从内存模型到实战场景，全方位解析Swift中类与结构体的核心差异。读完本文你将掌握：
- 类与结构体的5大本质区别及底层实现原理
- 值类型与引用类型的内存管理策略
- 初始化阶段的安全检查机制
- 继承与组合的取舍之道
- 性能优化场景下的类型选择决策树
一、类与结构体的核心能力对比（5分钟快速入门）
1.1 共同特性（基础能力）
类(Class)和结构体(Struct)作为Swift中的两种主要复合类型，具备以下共同功能：
| 能力 | 说明 | 代码示例 |
|---|---|---|
| 定义属性 | 存储值或引用数据 | var width: Double |
| 定义方法 | 提供功能实现 | func calculateArea() -> Double |
| 定义下标 | 通过下标语法访问元素 | subscript(index: Int) -> T |
| 遵循协议 | 实现协议规定的功能 | struct Circle: ShapeProtocol |
| 扩展功能 | 通过extension增加方法 | extension Int { func squared() -> Int } |
代码示例：结构体与类的共同特性
// 结构体示例
struct Resolution {
var width = 0
var height = 0
func aspectRatio() -> Double {
return Double(width)/Double(height)
}
subscript(axis: String) -> Int {
get {
return axis == "width" ? width : height
}
set {
if axis == "width" { width = newValue }
else { height = newValue }
}
}
}
// 类示例
class ViewController: UIViewController {
var resolution = Resolution()
var interlaced = false
override func viewDidLoad() {
super.viewDidLoad()
resolution.width = 1920
print("宽高比: \(resolution.aspectRatio())")
print("高度: \(resolution["height"])")
}
}
1.2 类独有的高级特性
类相比结构体增加了5项关键能力，这些能力使类更适合构建复杂的对象模型：
继承示例：
class Vehicle {
var currentSpeed = 0.0
var description: String {
return "行驶速度: \(currentSpeed) mph"
}
func makeNoise() {}
}
class Car: Vehicle {
var gear = 1
override var description: String {
return super.description + "，当前档位: \(gear)"
}
final func activateAirbags() {
// 安全气囊激活逻辑，不允许子类重写
}
}
class AutomaticCar: Car {
override var currentSpeed: Double {
didSet {
gear = Int(currentSpeed / 10.0) + 1
}
}
}
二、内存模型深度解析：值类型 vs 引用类型
2.1 内存分配机制（最核心差异）
值类型（结构体、枚举、基本类型）：
- 存储在栈内存(Stack)
- 变量直接持有数据本身
- 赋值或传递时复制整个数据
引用类型（类、闭包）：
- 存储在堆内存(Heap)
- 变量持有指向数据的引用（指针）
- 赋值或传递时复制引用地址
代码验证：
// 结构体（值类型）
var res1 = Resolution(width: 1024, height: 768)
var res2 = res1
res2.width = 1920
print(res1.width) // 输出: 1024（原始值未改变）
// 类（引用类型）
class Image {
var resolution: Resolution
init(resolution: Resolution) {
self.resolution = resolution
}
}
var img1 = Image(resolution: res1)
var img2 = img1
img2.resolution.width = 1920
print(img1.resolution.width) // 输出: 1920（原始值被改变）
2.2 引用计数与内存管理
类实例通过引用计数(ARC) 管理生命周期：
- 每个实例有一个引用计数器
- 强引用(Strong Reference)增加计数
- 无强引用时自动释放内存
循环引用风险与解决方案：
class Person {
let name: String
var apartment: Apartment?
init(name: String) { self.name = name }
deinit { print("\(name)被释放") }
}
class Apartment {
let unit: String
weak var tenant: Person? // 使用weak打破循环引用
init(unit: String) { self.unit = unit }
deinit { print("公寓\(unit)被释放") }
}
var john: Person? = Person(name: "John")
var unit4A: Apartment? = Apartment(unit: "4A")
john?.apartment = unit4A
unit4A?.tenant = john
john = nil // 输出: John被释放
unit4A = nil // 输出: 公寓4A被释放
三、初始化机制详解：安全与灵活的平衡
3.1 结构体的自动成员初始化器
结构体自动生成成员初始化器(Memberwise Initializer)，无需手动实现：
struct Size {
var width = 0.0, height = 0.0
}
// 自动生成的初始化器
let s1 = Size()
let s2 = Size(width: 100)
let s3 = Size(height: 200)
let s4 = Size(width: 100, height: 200)
3.2 类的初始化器规则
类的初始化遵循两段式初始化(Two-Phase Initialization)：
- 第一阶段：初始化所有存储属性
- 第二阶段：执行自定义初始化逻辑
代码示例：
class Human {
var gender: String
init() {
self.gender = "Female" // 阶段一：初始化属性
// 阶段二：自定义逻辑
}
}
class Person: Human {
var name: String
init(fullName name: String) {
// 阶段一：先初始化子类属性
self.name = name
// 阶段一：再调用父类初始化器
super.init()
// 阶段二：可以修改继承的属性
self.gender = "Male"
}
convenience init(shortName name: String) {
self.init(fullName: "\(name) Smith") // 便利初始化器必须调用指定初始化器
self.name = name // 阶段二：可以修改属性
}
}
四、实战场景选择指南：类还是结构体？
4.1 决策核心因素
| 选择结构体当... | 选择类当... |
|---|---|
| 数据简单且独立 | 需要继承功能 |
| 希望赋值时复制 | 需要引用标识 |
| 不需要生命周期管理 | 需要析构器释放资源 |
| 希望线程安全（隐式） | 需要类型转换 |
| 主要用于存储数据 | 需要复杂状态管理 |
4.2 典型应用场景
优先使用结构体的场景：
- 几何数据类型（Size、Point、Rect）
- 简单数据容器（UserInfo、Config）
- 临时计算结果（CalculationResult）
- 多线程环境下共享数据
优先使用类的场景：
- UI组件（ViewController、View）
- 复杂业务模型（User、Order）
- 需要共享状态的对象（DatabaseManager）
- 网络请求管理器（APIClient）
4.3 性能对比与优化建议
| 操作 | 结构体（值类型） | 类（引用类型） | 优化建议 |
|---|---|---|---|
| 赋值操作 | O(n) - 复制整个数据 | O(1) - 复制引用 | 大数据结构体考虑使用类 |
| 内存占用 | 栈内存分配（快速） | 堆内存分配（较慢） | 高频创建的临时对象用结构体 |
| 传递效率 | 大数据传递较慢 | 传递效率高 | 函数参数优先用结构体 |
| 线程安全 | 天然线程安全 | 需要同步机制 | 多线程共享用结构体 |
性能测试代码：
// 结构体性能测试
func testStructPerformance() {
var rects = [CGRect]()
let start = CACurrentMediaTime()
for _ in 0..<1_000_000 {
let rect = CGRect(x: 0, y: 0, width: 100, height: 100)
rects.append(rect)
}
let end = CACurrentMediaTime()
print("结构体耗时: \(end - start)秒")
}
// 类性能测试
class MyRect {
var x: CGFloat, y: CGFloat, width: CGFloat, height: CGFloat
init(x: CGFloat, y: CGFloat, width: CGFloat, height: CGFloat) {
self.x = x; self.y = y; self.width = width; self.height = height
}
}
func testClassPerformance() {
var rects = [MyRect]()
let start = CACurrentMediaTime()
for _ in 0..<1_000_000 {
let rect = MyRect(x: 0, y: 0, width: 100, height: 100)
rects.append(rect)
}
let end = CACurrentMediaTime()
print("类耗时: \(end - start)秒")
}
五、高级进阶：混合使用策略
5.1 组合优于继承（Composition Over Inheritance）
Swift更推荐使用组合而非继承来实现代码复用：
// 继承方式（不推荐）
class Bird { func fly() {} }
class Eagle: Bird { override func fly() {} }
class Penguin: Bird {
func fly() { fatalError("企鹅不会飞！") } // 违反里氏替换原则
}
// 组合方式（推荐）
protocol Flyable { func fly() }
struct FlyingBehavior: Flyable { func fly() {} }
struct NoFlyingBehavior: Flyable { func fly() {} }
class Bird {
var flyBehavior: Flyable
init(flyBehavior: Flyable) {
self.flyBehavior = flyBehavior
}
func performFly() { flyBehavior.fly() }
}
class Eagle: Bird {
init() { super.init(flyBehavior: FlyingBehavior()) }
}
class Penguin: Bird {
init() { super.init(flyBehavior: NoFlyingBehavior()) }
}
5.2 类与结构体的混合使用模式
推荐模式：类包含结构体
- 类管理生命周期和复杂逻辑
- 结构体存储数据和简单行为
class UserManager {
private var _userData: UserData // 结构体存储数据
var userName: String {
get { return _userData.name }
set { _userData.name = newValue }
}
init(userData: UserData) {
self._userData = userData
}
func saveUser() {
// 复杂的持久化逻辑
let data = try! JSONEncoder().encode(_userData)
// 保存到磁盘...
}
}
struct UserData: Codable {
var name: String
var age: Int
var preferences: [String: Bool]
}
六、常见问题与最佳实践
6.1 结构体中的mutating方法
结构体方法默认不能修改属性，需添加mutating关键字：
struct Counter {
var count = 0
mutating func increment() {
count += 1 // 允许修改属性
}
}
var counter = Counter()
counter.increment()
6.2 类的恒等运算符（===）
判断两个变量是否引用同一实例：
if viewControllerA === viewControllerB {
print("引用同一个ViewController实例")
}
6.3 避免循环引用的最佳实践
- 闭包中使用[weak self]：
class DataProcessor {
var completion: (() -> Void)?
var data: [Int] = []
func processData() {
DispatchQueue.global().async { [weak self] in
// 处理数据...
self?.data.append(1)
self?.completion?()
}
}
}
- 父子关系使用unowned：
class Country {
let name: String
var capital: City!
init(name: String, capitalName: String) {
self.name = name
self.capital = City(name: capitalName, country: self)
}
}
class City {
let name: String
unowned let country: Country // 城市一定属于某个国家，不会为nil
init(name: String, country: Country) {
self.name = name
self.country = country
}
}
七、总结与进阶学习
7.1 核心要点回顾
- 本质差异：结构体是值类型，类是引用类型
- 内存管理：结构体无需ARC，类通过引用计数管理
- 初始化：结构体自动生成成员初始化器，类需遵循两段式初始化
- 继承能力：类支持继承，结构体不支持
- 使用场景：简单数据用结构体，复杂对象用类
7.2 进阶学习路径
- 深入Swift值语义：研究Array、Dictionary的 copy-on-write 实现
- 高级内存管理：探索autoreleasepool和内存优化技巧
- Swift性能调优：使用Instruments分析值类型和引用类型的性能差异
- 协议导向编程：结合协议扩展实现类似"多继承"的功能
掌握类与结构体的正确使用是Swift开发的基础，也是写出高效、安全代码的关键。希望本文能帮助你在实际开发中做出更合理的技术选择，编写出更高质量的Swift代码！
如果觉得本文对你有帮助，请点赞收藏，关注获取更多Swift进阶内容！
创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
