Swift之旅_Language Guide5

本来打算一礼拜看完的,后来一鼓作气把最后3小节给看完了。


Memory Safety

这一小节主要讲解的是Swift中的内存安全,讲的是内存访问时候遇到的冲突问题。
发生内存访问冲突的条件:
1.至少一个是写访问。
2.它们在内存中访问相同的位置。
3.它们的持续时间重叠。
看一下冲突代码先:

var stepSize = 1    //这里是全局变量
func incrementInPlace(_ number: inout Int) {
    number += stepSize
}
incrementInPlace(&stepSize)
// Error: conflicting accesses to stepSize

其实后面的所讲的本质上也和这个大致一样,就是当你在对同一块内存同时进行读和写的时候可能会出错,一般都是编译时出错或者运行时崩溃。后面讲的是在结构体中内存访问冲突的问题,本质上和这个相差不多。附上一张图:
  • Conflicting Access to Properties

此外,像结元组、结构体这些值类型,对任何一个值进行修改都会改变整个值,这意味着读取或修改其中的一个属性需要对整个值进行读或写访问,例如面对元组和结构体重叠写入会产生冲突:

struct Player {
    var name: String
    var health: Int
    var energy: Int
    static let maxHealth = 10
    mutating func restoreHealth() {
        health = Player.maxHealth
    }
}
func balance(_ x: inout Int, _ y: inout Int) {
    let sum = x + y
    x = sum / 2
    y = sum - x
}    
var playerInformation = (health: 10, energy: 20)    //这里是全局变量
var holly = Player(name: "Holly", health: 100, energy: 10)//这里是全局变量
balance(&playerInformation.health, &playerInformation.energy)
// Error: conflicting access to properties of playerInformation
balance(&holly.health, &holly.energy) 
// Error

但是后面在局部变量中又是不会出错的:

func someFunction() {
    var oscar = Player(name: "Oscar", health: 10, energy: 10)
    balance(&oscar.health, &oscar.energy)  // OK
}

以下三个条件可以确保结构体的访问是安全的:
1.你只访问实例的存储属性,而不是计算的属性或类属性。
2.该结构题是局部变量的值,而不是全局变量。
3.该结构题不是由任何闭包捕获,或者仅由非逃逸闭包捕获。


Access Control

这一小节主要讲解的是Swift中的访问控制。

  • Access Control Syntax

访问控制的语法:

public class SomePublicClass {}
internal class SomeInternalClass {}
fileprivate class SomeFilePrivateClass {}
private class SomePrivateClass {}
 
public var somePublicVariable = 0
internal let someInternalConstant = 0
fileprivate func someFilePrivateFunction() {}
private func somePrivateFunction() {}
  • public&open:开放访问&公共访问,最开放的级别,等会儿有两者的区别介绍
  • internal:内部访问,使实体可以在其定义模块的任何源文件中使用,但不能在该模块之外的任* * 何源文件中使用。定义应用程序或框架的内部结构的时候使用。
  • fileprivate:文件私有访问,就是只能在当前文件中访问
  • private:私有访问,只能在实体内部中访问。
    开放访问时最高访问级别,私有访问时最低级别。开放访问只使用于类和类成员,它与公共访问的区别如下:
  • 公共访问权限的类或者小于它的只能在其定义的模块中进行子类化。
  • 公共访问权限的类或者小于它的只能由其定义的模块内的子类重写。
  • 开放访问权限的类可以在其定义的模块以及在任何导入该模块的模块中进行子类化。
  • 开放访问权限的类可以被其定义的模块以及在任何导入该模块的模块中的子类重写。
  • Custom Types

看下面一段代码:

public class SomePublicClass {                  // explicitly public class
    public var somePublicProperty = 0            // explicitly public class member
    var someInternalProperty = 0                 // implicitly internal class member
    fileprivate func someFilePrivateMethod() {}  // explicitly file-private class member
    private func somePrivateMethod() {}          // explicitly private class member
}
class SomeInternalClass {                       // implicitly internal class
    var someInternalProperty = 0                 // implicitly internal class member
    fileprivate func someFilePrivateMethod() {}  // explicitly file-private class member
    private func somePrivateMethod() {}          // explicitly private class member
}
fileprivate class SomeFilePrivateClass {        // explicitly file-private class
    func someFilePrivateMethod() {}              // implicitly file-private class member
    private func somePrivateMethod() {}          // explicitly private class member
}
private class SomePrivateClass {                // explicitly private class
    func somePrivateMethod() {}                  // implicitly private class member
}

类型的访问控制级别也影响该类型的成员(其属性、方法、初始化器和下标)的默认访问级别。如果将类型的访问级别定义为私有或文件私有,则其成员的默认访问级别也将是私有的或文件私有的。如果将类型的访问级别定义为内部或公共(或者使用内部的默认访问级别而不显式指定访问级别),则类型成员的默认访问级别将是内部的。
Ps:公共类型默认为具有内部成员,而不是公共成员。如果要将类型成员公开,则必须显式标记该类型成员。也就是说如果类型时public的,那么类型内部的成员(其属性、方法、初始化器和下标)默认是internal而不是public的。

  • Function Types

如下一段代码:

func someFunction() -> (SomeInternalClass, SomePrivateClass) {
    // function implementation goes here
}

SomeInternalClass是internal, SomePrivateClass是private,所以所返回的元组取低级别的private,因为函数的返回类型是私有的,所以你必须用private来修饰函数,应该如下代码写才对:

private func someFunction() -> (SomeInternalClass, SomePrivateClass) {
    // function implementation goes here
}
  • Constants, Variables, Properties, and Subscripts

将一个值赋值给常量、变量、属性和下标时,这个值的访问级别必须是高于或者等于常量、变量、属性和下标的访问级别。如下代码:

class Person: NSObject {
    private var book1 = Book()
    private class Book {
    }   
}

Book在这里是私有的,所以这里book1必须声明成私有以下的,如果大于私有则编译时出错。

  • Getters and Setters

也可以给常量、变量、属性和下标的setter和getter定义访问级别,但是setter和getter的访问级别不能高于其常量、变量、属性或下标的访问级别,如下代码:

struct TrackedString {
    internal(set) var numberOfEdits = 0
    var value: String = "" {
        didSet {
            numberOfEdits += 1
        }
    }
}
var stringToEdit = TrackedString()
stringToEdit.value = "This string will be tracked."
stringToEdit.numberOfEdits = 2

如结构体TrackedString中的numberOfEdits没有显示声明访问级别,所以它是internal,他的setter和getter不能高于internal。(PS: internal(set)是将numberOfEdits的setter访问级别设置成internal)
如果又想设置setter和getter的访问级别,又要设置常量、变量、属性和下标的访问级别可以这样写:

public struct TrackedString {
    public private(set) var numberOfEdits = 0
    public var value: String = "" {
        didSet {
            numberOfEdits += 1
        }
    }
    public init() {}
}

这样子TrackedString结构体中的numberOfEdits是公共访问级别,numberOfEdits的setter是私有访问级别。

  • Subclassing

Swift子类可以通过重写父类的属性或者方法达到超过其父类属性或者方法的访问级别,但是子类本身的访问级别不能大于父类访问级别:

public class A {
    fileprivate func someMethod() {}
}
 
internal class B: A {
    override internal func someMethod() {}
}

Advanced Operators

这一小节主要讲解的是Swift中的高级运算符。

  • itwise Operators

Bitwise NOT Operator:按位取反,将一个操作数的每一位都取反,使用如下:

let initialBits: UInt8 = 0b00001111
let invertedBits = ~initialBits  // equals 11110000

运算过程如图:
按位取反

Bitwise AND Operator:按位与,两个操作数同一位都位1时为1,使用如下:

let firstSixBits: UInt8 = 0b11111100
let lastSixBits: UInt8  = 0b00111111
let middleFourBits = firstSixBits & lastSixBits  // equals 00111100

运算过程如图:
按位与

Bitwise OR Operator:按位或,两个操作数同一位有一个为1时为1,使用如下:

let someBits: UInt8 = 0b10110010
let moreBits: UInt8 = 0b01011110
let combinedbits = someBits | moreBits  // equals 11111110

运算过程如图:
按位或

Bitwise XOR Operator:按位异或,两个操作数的同一位不同的时候为1,使用如下:

let firstBits: UInt8 = 0b00010100
let otherBits: UInt8 = 0b00000101
let outputBits = firstBits ^ otherBits  // equals 00010001

运算过程如图:
按位异或

Bitwise Left and Right Shift Operators:按位左移/右移,使用如下:

let shiftBits: UInt8 = 4   // 00000100 in binary
shiftBits << 1             // 00001000
shiftBits << 2             // 00010000
shiftBits << 5             // 10000000
shiftBits << 6             // 00000000
shiftBits >> 2             // 00000001
  • Overflow Operators

溢出操作符,如果尝试将数字插入到不能保存该值的整数常量或变量中,则默认情况下,Swift报告错误而不是允许创建无效值。如下代码会得到一个编译时的错误:

var potentialOverflow = Int16.max
// potentialOverflow equals 32767, which is the maximum value an Int16 can hold
potentialOverflow += 1
// this causes an error

当然,swift也提供一组溢出操作符来允许这一行为的发生。

  • 正方向溢出: &+
var unsignedOverflow = UInt8.max
// unsignedOverflow equals 255, which is the maximum value a UInt8 can hold
unsignedOverflow = unsignedOverflow &+ 1
// unsignedOverflow is now equal to 0

运算过程如图:
正方向溢出
  • 负方向溢出: &-
var unsignedOverflow = UInt8.min
// unsignedOverflow equals 0, which is the minimum value a UInt8 can hold
unsignedOverflow = unsignedOverflow &- 1
// unsignedOverflow is now equal to 255

运算过程如图:
负方向溢出

带符号操作的溢出时符号位也会参与运算,如下:

var signedOverflow = Int8.min
// signedOverflow equals -128, which is the minimum value an Int8 can hold
signedOverflow = signedOverflow &- 1
// signedOverflow is now equal to 127

运算过程如图:
带符号负方向溢出
  • Operator Methods

可以给类和结构体定义操作符,如下给一个结构定义一个+操作符:

struct Vector2D {
    var x = 0.0, y = 0.0
}
extension Vector2D {
    static func + (left: Vector2D, right: Vector2D) -> Vector2D {
        return Vector2D(x: left.x + right.x, y: left.y + right.y)
    }
}
let vector = Vector2D(x: 3.0, y: 1.0)
let anotherVector = Vector2D(x: 2.0, y: 4.0)
let combinedVector = vector + anotherVector
// combinedVector is a Vector2D instance with values of (5.0, 5.0)
  • Prefix and Postfix Operators

前缀和后缀运算符,定义如下:

extension Vector2D {
    static prefix func - (vector: Vector2D) -> Vector2D {
        return Vector2D(x: -vector.x, y: -vector.y)
    }
}
let positive = Vector2D(x: 3.0, y: 4.0)
let negative = -positive
// negative is a Vector2D instance with values of (-3.0, -4.0)
let alsoPositive = -negative
// alsoPositive is a Vector2D instance with values of (3.0, 4.0)
  • Compound Assignment Operators

复合赋值操作符

extension Vector2D {
    static func += (left: inout Vector2D, right: Vector2D) {
        left = left + right
    }
}
var original = Vector2D(x: 1.0, y: 2.0)
let vectorToAdd = Vector2D(x: 3.0, y: 4.0)
original += vectorToAdd
// original now has values of (4.0, 6.0)
  • Equivalence Operators

相等操作符

extension Vector2D: Equatable {
    static func == (left: Vector2D, right: Vector2D) -> Bool {
        return (left.x == right.x) && (left.y == right.y)
    }
}
let twoThree = Vector2D(x: 2.0, y: 3.0)
let anotherTwoThree = Vector2D(x: 2.0, y: 3.0)
if twoThree == anotherTwoThree {
    print("These two vectors are equivalent.")
}
// Prints "These two vectors are equivalent."
  • Custom Operators

自定义运算符,swift中可以自定义运算符,需要用前缀、中缀或后缀修饰符标记:

prefix operator +++    //  声明成全局的
extension Vector2D {
    static prefix func +++ (vector: inout Vector2D) -> Vector2D {
        vector += vector
        return vector
    }
}
var toBeDoubled = Vector2D(x: 1.0, y: 4.0)
let afterDoubling = +++toBeDoubled
// toBeDoubled now has values of (2.0, 8.0)
// afterDoubling also has values of (2.0, 8.0)
  • Precedence for Custom Infix Operators

自定义中缀运算符的优先级

infix operator +-: AdditionPrecedence
extension Vector2D {
    static func +- (left: Vector2D, right: Vector2D) -> Vector2D {
        return Vector2D(x: left.x + right.x, y: left.y - right.y)
    }
}
let firstVector = Vector2D(x: 1.0, y: 2.0)
let secondVector = Vector2D(x: 3.0, y: 4.0)
let plusMinusVector = firstVector +- secondVector
// plusMinusVector is a Vector2D instance with values of (4.0, -2.0)

这里的AdditionPrecedence是一个优先级组(与加法同一级别)。未显式放置到优先组中的自定义中缀运算符被赋予默认优先级组,其优先级高于三目运算符的优先级。


总算是看完了,官方文档中剩下貌似不需要去特别关注。看完之后发现之前去大公司面试的时候被问的好多答不上来的东西,看过官方文档之后算是有了点逼数了。不过这并没有结束,看完官方文档又得进入下一个学习环节啦~

推荐阅读更多精彩内容

  • 本章将会介绍 模块和源文件访问级别访问控制语法自定义类型子类常量、变量、属性、下标构造器协议扩展泛型类型别名位运算...
    寒桥阅读 238评论 0 2
  • 扩展 扩展就是向一个已有的类、结构体、枚举类型或者协议类型添加新功能。这包括在没有权限获取原始源代码的情况下扩展类...
    cht005288阅读 51评论 0 0
  • 136.泛型 泛型代码让你可以写出灵活,可重用的函数和类型,它们可以使用任何类型,受你定义的需求的约束。你可以写出...
    无沣阅读 491评论 0 4
  • Hello Word 在屏幕上打印“Hello, world”,可以用一行代码实现: 你不需要为了输入输出或者字符...
    restkuan阅读 756评论 0 5
  • 访问控制 可以限定其它源文件或模块中的代码对你的代码的访问级别。这个特性可以让我们隐藏代码的一些实现细节,并且可以...
    答案MK阅读 44评论 0 0