# 访问控制、内存管理、字面量、模式匹配


### 1、访问控制

Swift 提供了5个不同的访问级别：open > public > internal > fileprivate > private  
open：允许在定义实体的模块、其他模块中访问，允许其他模块进行继承、重写（open只能用在类、类成员上）。  
public：允许在定义实体的模块、其他模块中访问，不允许其他模块进行继承、重写。  
internal：只允许在定义实体的模块中访问，不允许在其他模块中访问。绝大部分实体默认都是该级别。  
fileprivate：只允许在定义实体的源文件中访问。  
private：只允许在定义实体的封闭声明中访问。

**使用规则：**   
一个实体不可以被更低访问级别的实体定义，比如：  
变量\\常量类型 ≥ 变量\\常量  
参数类型、返回值类型 ≥ 函数  
父类 ≥ 子类  
父协议 ≥ 子协议  
原类型 ≥ typealias  
原始值类型、关联值类型 ≥ 枚举类型  
定义类型A时用到的其他类型 ≥ 类型A

**元组：**   
元组类型的访问级别是所有成员类型最低的那个。

**泛型类型：**   
泛型类型的访问级别是`类型的访问级别`以及`所有泛型类型参数的访问级别`中最低的那个。

**成员、嵌套类型：**   
类型的访问级别会影响成员（属性、方法、初始化器、下标）、嵌套类型的默认访问级别。若类型为 private 或 fileprivate，那么成员\\嵌套类型默认也是 private 或 fileprivate；若类型为 internal 或 public，那么成员\\嵌套类型默认是 internal。

**成员的重写：**   
1、子类重写成员的访问级别必须 ≥ 子类的访问级别/父类被重写成员的访问级别。  
2、父类的成员不能被成员作用域外定义的子类重写。

**全局作用域：**   
直接在全局作用域下定义的 private 等价于 fileprivate。

**getter、setter：**   
getter、setter 默认自动接收它们所属环境的访问级别。也可以给 setter 单独设置一个比 getter 更低的访问级别，用以限制写的权限。

**初始化器：**   
1、如果一个 public 类想在另一个模块调用编译生成的默认无参初始化器，必须显式提供 public 的无参初始化器。因为 public 类的默认初始化器是 internal 级别。  
2、required 初始化器 ≥ 它的默认访问级别。  
3、如果结构体有 private\\fileprivate 的存储实例属性，那么它的成员初始化器也是 private\\fileprivate，否则默认就是 internal。

**枚举类型的 case：**   
1、不能给 enum 的每个 case 单独设置访问级别  
2、每个 case 自动接收 enum 的访问级别，enum 为 public 时 case 也是 public。

**协议：**   
1、协议中定义的要求自动接收协议的访问级别，不能单独设置访问级别。public 协议定义的要求也是 public。  
2、协议实现的访问级别必须 ≥ 类型的访问级别 / 协议的访问级别。

**扩展：**   
1、如果有显式设置扩展的访问级别，扩展添加的成员自动接收扩展的访问级别。如果没有显式设置扩展的访问级别，扩展添加的成员的默认访问级别，跟直接在类型中定义的成员一样。  
2、可以单独给扩展添加的成员设置访问级别。  
3、不能给用于遵守协议的扩展显式设置扩展的访问级别。  
4、在同一文件中的扩展，可以写成类似多个部分的类型声明。在原本的声明中声明一个私有成员，可以在同一文件的扩展中访问它。在扩展中声明一个私有成员，可以在同一文件的其他扩展中、原本声明中访问它。

### 2、内存管理

跟 OC 一样，Swift 也是采取基于引用计数的 ARC 内存管理方案（针对堆空间）。  
Swift 的 ARC 中有3种引用  
1、强引用（strong reference）：默认情况下，引用都是强引用。  
2、弱引用（weak reference）：通过 weak 定义弱引用。必须是可选类型的 var，因为实例销毁后，ARC 会自动将弱引用设置为 nil。ARC 自动给弱引用设置 nil 时，不会触发属性观察器。  
3、无主引用（unowned reference）：通过 unowned 定义无主引用。它不会产生强引用，实例销毁后仍然存储着实例的内存地址（类似于OC中的 unsafe_unretained）。试图在实例销毁后访问无主引用，会产生运行时错误（野指针）。

**weak、unowned 的使用条件：** 只能用在类实例上面。

**循环引用：**   
weak、unowned 都能解决循环引用的问题，unowned 要比 weak 少一些性能消耗。在生命周期中可能会变为 nil 的使用 weak。初始化赋值后再也不会变为 nil 的使用 unowned。

**闭包的循环引用：**   
1、闭包表达式默认会对用到的外层对象产生额外的强引用（对外层对象进行了 retain 操作）。在闭包表达式的捕获列表声明 weak 或 unowned 引用，解决循环引用问题。  
2、如果想在定义闭包属性的同时引用 self，这个闭包必须是 lazy 的（因为在实例初始化完毕之后才能引用 self）。  
3、如果 lazy 属性是闭包调用的结果，那么不用考虑循环引用的问题（因为闭包调用后，闭包的生命周期就结束了）。

**@escaping：**   
1、非逃逸闭包、逃逸闭包，一般都是当做参数传递给函数。  
非逃逸闭包：闭包调用发生在函数结束前，闭包调用在函数作用域内。  
逃逸闭包：闭包有可能在函数结束后调用，闭包调用逃离了函数的作用域，需要通过 @escaping 声明。  
2、逃逸闭包不可以捕获 inout 参数。

**内存访问冲突：**   
内存访问冲突会在两个访问满足下列条件时发生：  
1、至少一个是写入操作。  
2、它们访问的是同一块内存。  
3、它们的访问时间重叠（比如在同一个函数内）。

```swift
 func plus(_ num: inout Int) -> Int { num + 1 }
var number = 1
number = plus(&number) 
```

```swift
 var step = 1
func increment(_ num: inout Int) { num += step }
increment(&step) 
```

```swift
 var copyOfStep = step
increment(&copyOfStep)
step = copyOfStep 
```

```swift
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) 
```

```swift
struct Player {
    var name: String
    var health: Int
    var energy: Int
    mutating func shareHealth(with teammate: inout Player) {
        balance(&teammate.health, &health)
    }
}
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) 
```

```swift
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、只访问实例存储属性，不是计算属性或者类属性。  
2、结构体是局部变量而非全局变量。  
3、结构体要么没有被闭包捕获要么只被非逃逸闭包捕获。

```swift
 func test() {
    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)
}
test() 
```

**指针**  
1、Swift 中也有专门的指针类型，这些都被定性为 `Unsafe`（不安全的），常见的有以下4种类型:  
`UnsafePointer<Pointee> `类似于 const Pointee *。  
`UnsafeMutablePointer<Pointee> ` 类似于 Pointee *。  
UnsafeRawPointer 类似于 const void *。  
UnsafeMutableRawPointer 类似于 void *。

```swift
var age = 10
func test1(_ ptr: UnsafeMutablePointer<Int>) {
    ptr.pointee += 10
}
func test2(_ ptr: UnsafePointer<Int>) {
    print(ptr.pointee)
}
test1(&age)
test2(&age) 
print(age) 
```

```swift
var age = 10
func test3(_ ptr: UnsafeMutableRawPointer) {
    ptr.storeBytes(of: 20, as: Int.self)
}
func test4(_ ptr: UnsafeRawPointer) {
    print(ptr.load(as: Int.self))
}
test3(&age)
test4(&age) 
print(age) 
```

2、应用

```swift
var arr = NSArray(objects: 11, 22, 33, 44)
arr.enumerateObjects { (obj, idx, stop) in
    print(idx, obj)
    if idx == 2 { 
        stop.pointee = true
    }
} 
```

```swift
var arr = NSArray(objects: 11, 22, 33, 44)
for (idx, obj) in arr.enumerated() {
    print(idx, obj)
    if idx == 2 {
        break
    }
} 
```

3、获得指向某个变量的指针

```swift
var age = 11
var ptr1 = withUnsafeMutablePointer(to: &age) { $0 }
var ptr2 = withUnsafePointer(to: &age) { $0 }
ptr1.pointee = 22
print(ptr2.pointee) 
print(age) 

var ptr3 = withUnsafeMutablePointer(to: &age) { UnsafeMutableRawPointer($0) }
var ptr4 = withUnsafePointer(to: &age) { UnsafeRawPointer($0) }
ptr3.storeBytes(of: 33, as: Int.self)
print(ptr4.load(as: Int.self)) 
print(age) 
```

4、获得指向堆空间实例的指针

```swift
class Person {}
var person = Person()
var ptr = withUnsafePointer(to: &person) { UnsafeRawPointer($0) }
var heapPtr = UnsafeRawPointer(bitPattern: ptr.load(as: UInt.self))
print(heapPtr!) 
```

5、创建指针

```swift
var ptr = UnsafeRawPointer(bitPattern: 0x100001234) 
```

```swift
 var ptr = malloc(16)

ptr?.storeBytes(of: 11, as: Int.self)
ptr?.storeBytes(of: 22, toByteOffset: 8, as: Int.self)

print((ptr?.load(as: Int.self))!) 
print((ptr?.load(fromByteOffset: 8, as: Int.self))!) 

free(ptr) 
```

```swift
var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)
ptr.storeBytes(of: 11, as: Int.self)
ptr.advanced(by: 8).storeBytes(of: 22, as: Int.self)
print(ptr.load(as: Int.self)) 
print(ptr.advanced(by: 8).load(as: Int.self)) 
ptr.deallocate()
var ptr = UnsafeRawPointer(bitPattern: 0x100001234) 
```

```swift
var ptr = UnsafeMutablePointer<Int>.allocate(capacity: 3)
ptr.initialize(to: 11)
ptr.successor().initialize(to: 22)
ptr.successor().successor().initialize(to: 33)

print(ptr.pointee) 
print((ptr + 1).pointee) 
print((ptr + 2).pointee) 

print(ptr[0]) 
print(ptr[1]) 
print(ptr[2]) 

ptr.deinitialize(count: 3)
ptr.deallocate() 
```

```swift
class Person {
    var age: Int
    var name: String
    init(age: Int, name: String) {
        self.age = age
        self.name = name
    }
    deinit { print(name, "deinit") }
} 
```

```swift
var ptr = UnsafeMutablePointer<Person>.allocate(capacity: 3)
ptr.initialize(to: Person(age: 10, name: "Jack"))
(ptr + 1).initialize(to: Person(age: 11, name: "Rose"))
(ptr + 2).initialize(to: Person(age: 12, name: "Kate"))

ptr.deinitialize(count: 3)
ptr.deallocate() 
```

6、指针转换

```swift
var ptr = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1)
ptr.assumingMemoryBound(to: Int.self).pointee = 11
(ptr + 8).assumingMemoryBound(to: Double.self).pointee = 22.0
print(unsafeBitCast(ptr, to: UnsafePointer<Int>.self).pointee) 
print(unsafeBitCast(ptr + 8, to: UnsafePointer<Double>.self).pointee) 
ptr.deallocate() 
```

unsafeBitCast 是忽略数据类型的强制转换，不会因为数据类型的变化而改变原来的内存数据。

```swift
class Person {}
var person = Person()
var ptr = unsafeBitCast(person, to: UnsafeRawPointer.self)
print(ptr) 
```

### 3、字面量

常见字面量（Literal）的默认类型：  
public typealias IntegerLiteralType = Int  
public typealias FloatLiteralType = Double  
public typealias BooleanLiteralType = Bool  
public typealias StringLiteralType = String

```swift
 typealias FloatLiteralType = Float
typealias IntegerLiteralType = UInt8
var age = 10 
var height = 1.68 
```

Swift 自带的绝大部分类型，都支持直接通过字面量进行初始化：Bool、Int、Float、Double、String、Array、Dictionary、Set、Optional 等。Swift 自带类型之所以能够通过字面量初始化，是因为它们遵守了对应的协议。  
Bool : ExpressibleByBooleanLiteral  
Int : ExpressibleByIntegerLiteral  
Float、Double : ExpressibleByIntegerLiteral、ExpressibleByFloatLiteral  
Dictionary : ExpressibleByDictionaryLiteral  
String : ExpressibleByStringLiteral  
Array、Set : ExpressibleByArrayLiteral  
Optional : ExpressibleByNilLiteral

**字面量协议应用**

```swift
extension Int : ExpressibleByBooleanLiteral {
    public init(booleanLiteral value: Bool) { self = value ? 1 : 0 }
}
var num: Int = true
print(num) 
```

```swift
class Student : ExpressibleByIntegerLiteral, ExpressibleByFloatLiteral, ExpressibleByStringLiteral, CustomStringConvertible {
    var name: String = ""
    var score: Double = 0
    required init(floatLiteral value: Double) { self.score = value }
    required init(integerLiteral value: Int) { self.score = Double(value) }
    required init(stringLiteral value: String) { self.name = value }
    required init(unicodeScalarLiteral value: String) { self.name = value }
    required init(extendedGraphemeClusterLiteral value: String) { self.name = value }
    var description: String { "name=\(name),score=\(score)" }
}
var stu: Student = 90
print(stu) 
stu = 98.5
print(stu) 
stu = "Jack"
print(stu) 
```

```swift
struct Point {
    var x = 0.0, y = 0.0
}
extension Point : ExpressibleByArrayLiteral, ExpressibleByDictionaryLiteral {
    init(arrayLiteral elements: Double...) {
        guard elements.count > 0 else { return }
        self.x = elements[0]
        guard elements.count > 1 else { return }
        self.y = elements[1]
    }
    init(dictionaryLiteral elements: (String, Double)...) {
        for (k, v) in elements {
            if k == "x" { self.x = v } else if k == "y" { self.y = v }
        }
    }
}
var p: Point = [10.5, 20.5]
print(p) 
p = ["x" : 11, "y" : 22]
print(p) 
```

### 4、模式匹配

模式是用于匹配的规则，比如 switch 的 case、捕捉错误的 catch、if\\guard\\while\\for 语句的条件等。  
Swift中的模式有：  
通配符模式（Wildcard Pattern）  
标识符模式（Identifier Pattern）  
值绑定模式（Value-Binding Pattern）  
元组模式（Tuple Pattern）  
枚举 Case 模式（Enumeration Case Pattern）  
可选模式（Optional Pattern）  
类型转换模式（Type-Casting Pattern）  
表达式模式（Expression Pattern）

**通配符模式（Wildcard Pattern）：**   
_ 匹配任何值  
_? 匹配非 nil 值

```swift
enum Life {
    case human(name: String, age: Int?)
    case animal(name: String, age: Int?)
}
func check(_ life: Life) {
    switch life {
        case .human(let name, _):
        print("human", name)
    case .animal(let name, _?):
        print("animal", name)
    default:
        print("other")
    }
}
check(.human(name: "Rose", age: 20)) 
check(.human(name: "Jack", age: nil)) 
check(.animal(name: "Dog", age: 5)) 
check(.animal(name: "Cat", age: nil)) 
```

**标识符模式（Identifier Pattern）**  
给对应的变量、常量名赋值

```swift
var age = 10
let name = "jack" 
```

**值绑定模式（Value-Binding Pattern）**

```swift
let point = (3, 2)
switch point {
case let (x, y):
    print("The point is at (\(x), \(y)).")
} 
```

**元组模式（Tuple Pattern）**

```swift
let points = [(0, 0), (1, 0), (2, 0)]
for (x, _) in points {
    print(x)
} 
```

```swift
let name: String? = "jack"
let age = 18
let info: Any = [1, 2]
switch (name, age, info) {
    case (_?, _ , _ as String):
        print("case")
    default:
        print("default")
} 
```

```swift
var scores = ["jack" : 98, "rose" : 100, "kate" : 86]
for (name, score) in scores {
    print(name, score)
} 
```

**枚举 Case 模式（Enumeration Case Pattern）**  
if case 语句等价于只有1个 case 的 switch 语句

```swift
let age = 2

if age >= 0 && age <= 9 {
    print("[0, 9]")
}

if case 0...9 = age {
    print("[0, 9]")
}
guard case 0...9 = age else { return }
print("[0, 9]") 
```

```swift
switch age {
    case 0...9: print("[0, 9]")
    default: break
} 
```

```swift
let ages: [Int?] = [2, 3, nil, 5]
for case nil in ages {
    print("有nil值")
    break
} 
```

```swift
let points = [(1, 0), (2, 1), (3, 0)]
for case let (x, 0) in points {
    print(x)
} 
```

**可选模式（Optional Pattern）**

```swift
let age: Int? = 42
if case .some(let x) = age { print(x) }
if case let x? = age { print(x) } 
```

```
let ages: [Int?] = [nil, 2, 3, nil, 5]
for case let age? in ages {
    print(age)
} 
```

```swift
let ages: [Int?] = [nil, 2, 3, nil, 5]
for item in ages {
    if let age = item {
        print(age)
    }
} 
```

```swift
func check(_ num: Int?) {
    switch num {
        case 2?: print("2")
        case 4?: print("4")
        case 6?: print("6")
        case _?: print("other")
        case _: print("nil")
    }
}
check(4) 
check(8) 
check(nil) 
```

**类型转换模式（Type-Casting Pattern）**

```swift
let num: Any = 6
switch num {
    case is Int:
        
        print("is Int", num)
    
        
    default:
        break
} 
```

```swift
class Animal { func eat() { print(type(of: self), "eat") } }
class Dog : Animal { func run() { print(type(of: self), "run") } }
class Cat : Animal { func jump() { print(type(of: self), "jump") } }
func check(_ animal: Animal) {
    switch animal {
    case let dog as Dog:
        dog.eat()
        dog.run()
    case is Cat:
        animal.eat()
    default: break
    }
}

check(Dog())

check(Cat()) 
```

**表达式模式（Expression Pattern）**  
表达式模式用在 case 中

```swift
let point = (1, 2)
switch point {
    case (0, 0):
        print("(0, 0) is at the origin.")
    case (-2...2, -2...2):
        print("(\(point.0), \(point.1)) is near the origin.")
    default:
        print("The point is at (\(point.0), \(point.1)).")
} 
```

**自定义表达式模式**  
可以通过重载运算符，自定义表达式模式的匹配规则。

```swift
struct Student {
    var score = 0, name = ""
    static func ~= (pattern: Int, value: Student) -> Bool { value.score >= pattern }
    static func ~= (pattern: ClosedRange<Int>, value: Student) -> Bool { pattern.contains(value.score) }
    static func ~= (pattern: Range<Int>, value: Student) -> Bool { pattern.contains(value.score) }
} 
```

```swift
var stu = Student(score: 75, name: "Jack")
switch stu {
case 100: print(">= 100")
case 90: print(">= 90")
case 80..<90: print("[80, 90)")
case 60...79: print("[60, 79]")
case 0: print(">= 0")
default: break
} 
```

```swift
if case 60 = stu {
    print(">= 60")
} 
```

```swift
var info = (Student(score: 70, name: "Jack"), "及格")
switch info {
case let (60, text): print(text)
default: break
} 
```

```swift
extension String {
    static func ~= (pattern: (String) -> Bool, value: String) -> Bool {
        pattern(value)
    }
}
func hasPrefix(_ prefix: String) -> ((String) -> Bool) { { $0.hasPrefix(prefix) } }
func hasSuffix(_ suffix: String) -> ((String) -> Bool) { { $0.hasSuffix(suffix) } }
var str = "jack"
switch str {
case hasPrefix("j"), hasSuffix("k"):
    print("以j开头，以k结尾")
default: break
} 
```

```swift
func isEven(_ i: Int) -> Bool { i % 2 == 0 }
func isOdd(_ i: Int) -> Bool { i % 2 != 0 }
extension Int {
    static func ~= (pattern: (Int) -> Bool, value: Int) -> Bool {
        pattern(value)
    }
}

var age = 9
switch age {
case isEven:
    print("偶数")
case isOdd:
    print("奇数")
default:
    print("其他")
} 
```

```swift
prefix operator ~>
prefix operator ~>=
prefix operator ~<
prefix operator ~<=
prefix func ~> (_ i: Int) -> ((Int) -> Bool) { { $0 > i } }
prefix func ~>= (_ i: Int) -> ((Int) -> Bool) { { $0 >= i } }
prefix func ~< (_ i: Int) -> ((Int) -> Bool) { { $0 < i } }
prefix func ~<= (_ i: Int) -> ((Int) -> Bool) { { $0 <= i } }

var age = 9
switch age {
case ~>=0:
    print("1")
case ~>10:
    print("2")
default: break
} 
```

**where**  
可以使用 where 为模式匹配增加匹配条件

```swift
var data = (10, "Jack")
switch data {
case let (age, _) where age > 10:
    print(data.1, "age>10")
case let (age, _) where age > 0:
    print(data.1, "age>0")
default: break
} 
```

```swift
var ages = [10, 20, 44, 23, 55]
for age in ages where age > 30 {
    print(age)
} 
```

```swift
protocol Stackable { associatedtype Element }
protocol Container {
    associatedtype Stack : Stackable where Stack.Element : Equatable
} 
```

```swift
func equal<S1: Stackable, S2: Stackable>(_ s1: S1, _ s2: S2) -> Bool where S1.Element == S2.Element, S1.Element : Hashable {
    return false
} 
```

```swift
extension Container where Self.Stack.Element : Hashable { } 
```

### 注：

方法也可以像函数那样，赋值给一个 let 或者 var。

```swift
struct Person {
    var age: Int
    func run(_ v: Int) { print("func run", age, v) }
    static func run(_ v: Int) { print("static func run", v) }
} 
```

```swift
let fn1 = Person.run
fn1(10) 
let fn2: (Int) -> () = Person.run
fn2(20) 
let fn3: (Person) -> ((Int) -> ()) = Person.run
fn3(Person(age: 18))(30) 
```




---

> 作者: 宋明  
> URL: https://apolla.cc/posts/%E8%AE%BF%E9%97%AE%E6%8E%A7%E5%88%B6%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86%E5%AD%97%E9%9D%A2%E9%87%8F%E6%A8%A1%E5%BC%8F%E5%8C%B9%E9%85%8D/  

