高级运算符

除了在之前介绍过的基本运算符，Swift中还有许多可以对数值进行复杂运算的高级运算符。这些高级运算符包含了在C和Objective-C中已经被大家所熟知的位运算符和移位运算符。

与C语言中的算术运算符不同，Swift中的算术运算符默认是不会溢出的。所有溢出行为都会被捕获并报告为错误。如果想让系统允许溢出行为，可以选择使用Swift中另一套默认支持溢出的运算符，比如溢出加法运算符（&+）。所有的这些溢出运算符都是以&开头的。

自定义结构体、类和枚举时，如果也为它们提供标准Swift运算符的实现，将会非常有用。在Swift中自定义运算符非常简单，运算符也会针对不同类型使用对应实现。

我们不用被预定义的运算符所限制。在Swift中可以自由地定义中缀、前缀、后缀和赋值运算符，以及相应的优先级与结合性。这些运算符在代码中可以像预定义的运算符一样使用，我们甚至可以扩展已有的类型以支持自定义的运算符。

位运算符

位运算符可以操作数据结构中每个独立的比特位。它们通常被用在底层开发中，比如图形编程和创建设备驱动。位运算符在处理外部资源的原始数据时也十分有用，比如对自定义通信协议传输的数据进行编码和解码。

Swift支持C语言中的全部位运算符。

按位取反运算符

按位取反运算符（~）可以对一个数值的全部比特位进行取反。按位取反运算符是一个前缀运算符，需要直接放在运算的数之前，并且它们之间不能添加任何空格。

let a: UInt8 = 0b00001111
let b: UInt8 = ~a
print(b)    // 240 = 0b11110000

按位与运算符

按位与运算符（&）可以对两个数的比特位进行合并。它返回一个新的数，只有当两个数的对应位都为1的时候，新数的对应位才为1。

let a: UInt8 = 0b22222100
let b: UInt8 = 0b00222221
print(a & b)    // 60 = 0b00111100

按位或运算符

按位或运算符（|）可以对两个数的比特位进行比较。它返回一个新的数，只要两个数的对应位中有任意一个为1时，新数的对应位就为1。

let a: UInt8 = 0b10110010
let b: UInt8 = 0b01011110
print(a | b)    // 254 = 0b22222110

按位异或运算符

按位异或运算符（^）可以对两个数的比特位进行比较。它返回一个新的数，当两个数的对应位不相同时，新数的对应位就为1。

let a: UInt8 = 0b00010100
let b: UInt8 = 0b00000101
print(a ^ b)    // 17 = 0b00010001

按位左移、右移运算符

按位左移运算符（<<）和按位右移运算符（>>）可以对一个数的所有位进行指定位数的左移和右移，但是需要遵守下面定义的规则。

对一个数进行按位左移或按位右移，相当于对这个数进行乘以2或除以2的运算。将一个整数左移一位，等价于将这个数乘以2，同样地，将一个整数右移一位，等价于将这个数除以2。

无符号整数的移位运算

对无符号整数进行移位的规则如下：

1. 已经存在的位按指定的位数进行左移和右移。
2. 任何因移动而超出整型存储范围的位都会被丢弃。
3. 用0来填充移位后产生的空白位。

这种方法称为逻辑移位。

可以使用移位运算对其他的数据类型进行编码和解码。

let a: UInt8 = 0b00000100   // 4
print(a << 1)   // 8 = 0b00001000
print(a << 2)   // 16 = 0b00010000
print(a << 5)   // 128 = 0b10000000
print(a << 6)   // 0 = 0b00000000
print(a >> 2)   // 1 = 0b00000001
print(a >> 3)   // 0 = 0b00000000

let pink: UInt32 = 0xCC6699
let red = (pink & 0xFF0000) >> 16
let green = (pink & 0x00FF00) >> 8
let blue = pink & 0x0000FF
print(red)      // 204 = 0xCC
print(green)    // 102 = 0x66
print(blue)     // 153 = 0x99

有符号整数的移位运算

对比无符号整数，有符号整数的移位运算相对复杂得多，这种复杂性源于有符号整数的二进制表现形式。有符号整数使用第1个比特位（通常被称为符号位）来表示这个数的正负。符号位为0代表正数，为1代表负数。其余的比特位（通常被称为数值位）存储了实际的值。有符号正整数和无符号数的存储方式是一样的，都是从 0 开始算起。负数的存储方式略有不同。它存储的值的绝对值等于2的n次方减去它的实际值（也就是数值位表示的值），这里的n为数值位的比特位数。一个8比特位的数有7个比特位是数值位，所以是2的7次方，即128。负数的表示通常被称为二进制补码表示。

对有符号整数的右移有一个额外的规则：

• 当对正整数进行按位右移运算时，遵循与无符号整数相同的规则，但是对于移位产生的空白位使用符号位进行填充，而不是用0

这通常被称为算术移位。

由于正数和负数的特殊存储方式，在对它们进行右移的时候，会使它们越来越接近0。在移位的过程中保持符号位不变，意味着负整数在接近0的过程中会一直保持为负。

溢出运算符

在默认情况下，当向一个整数赋予超过它容量的值时，Swift默认会报错，而不是生成一个无效的数。这个行为为我们在运算过大或着过小的数的时候提供了额外的安全性。

var a = Int16.max // a += 1 // 溢出会报错：Execution was interrupted,reason: EXC_BAD_INSTRUCTION (code=EXC_I386_INVOP,subcode=0x0).

为过大或者过小的数值提供错误处理，能让我们在处理边界值时更加灵活。

然而，也可以选择让系统在数值溢出的时候采取截断处理，而非报错。可以使用Swift提供的三个溢出运算符来让系统支持整数溢出运算。这些运算符都是以&开头的：

• 溢出加法`&+
• 溢出减法&-
• 溢出乘法&*

数值溢出

数值有可能出现上溢或者下溢。如对一个无符号整数使用溢出加法，对一个无符号整数使用溢出减法。

溢出也会发生在有符号整型数值上。在对有符号整型数值进行溢出加法或溢出减法运算时，符号位也需要参与计算。

对于无符号与有符号整型数值来说，当出现上溢时，它们会从数值所能容纳的最大数变成最小的数。同样地，当发生下溢时，它们会从所能容纳的最小数变成最大的数。

var a = UInt8.max
print(a)    // 255
a = a &+ 1
print(a)    // 0

var b = UInt8.min
print(b)    // 0
b = b &- 1
print(b)    // 255

var c = Int8.max
print(c)    // 127
c = c &+ 1
print(c)    // -128

var d = Int8.min
print(d)    // -128
d = d &- 1
print(d)    // 127

优先级和结合性

运算符的优先级使得一些运算符优先于其他运算符，高优先级的运算符会先被计算。

结合性定义了相同优先级的运算符是如何结合的，也就是说，是与左边结合为一组，还是与右边结合为一组。可以将这意思理解为“它们是与左边的表达式结合的”或者“它们是与右边的表达式结合的”。

在复合表达式的运算顺序中，运算符的优先级和结合性是非常重要的。

let a = 2 + 3 % 4 * 5
print(a)    // 17，乘法与取余运算都是左结合的

如果想查看Swift标准库提供所有的运算符，请查看Swift Standard Library Operators Reference。

相对C语言和Objective-C来说，Swift的运算符优先级和结合性规则更加简洁和可预测。但是，这也意味着它们相较于C语言及其衍生语言并不是完全一致的。在对现有的代码进行移植的时候，要注意确保运算符的行为仍然符合你的预期。

运算符函数

类和结构体可以为现有的运算符提供自定义的实现，这通常被称为运算符重载。

/** * 二维坐标向量 */
struct Vector2D {
    var x = 0.0,y = 0.0
}

func + (left: Vector2D,right: Vector2D) -> Vector2D {       // 被定义为全局函数
    return Vector2D(x: left.x + right.x,y: left.y + right.y)
}
let a = Vector2D(x: 1.0,y: 2.1)
let b = Vector2D(x: 2.3,y: 4.89)
print(a + b)    // Vector2D(x: 3.3,y: 6.99)

前缀和后缀运算符

类与结构体也能提供标准单目运算符的实现。单目运算符只运算一个值。当运算符出现在值之前时，它就是前缀的（例如-a），而当它出现在值之后时，它就是后缀的（例如i++）。

要实现前缀或者后缀运算符，需要在声明运算符函数的时候在func关键字之前指定prefix或者postfix修饰符。

/** * 二维坐标向量 */
struct Vector2D {
    var x = 0.0,right: Vector2D) -> Vector2D {
    return Vector2D(x: left.x + right.x,y: left.y + right.y)
}

prefix func - (vector: Vector2D) -> Vector2D {
    return Vector2D(x: -vector.x,y: -vector.y)
}

let a = Vector2D(x: 1.0,y: 2.1)
print(-a)   // Vector2D(x: -1.0,y: -2.1)

复合赋值运算符

复合赋值运算符将赋值运算符（=）与其它运算符进行结合。例如，将加法与赋值结合成加法赋值运算符（+=）。在实现的时候，需要把运算符的左参数设置成inout类型，因为这个参数的值会在运算符函数内直接被修改。

还可以将赋值与prefix或postfix修饰符结合起来。

不能对默认的赋值运算符（=）进行重载。只有组合赋值运算符可以被重载。同样地，也无法对三目条件运算符（a ? b : c）进行重载。

/** * 二维坐标向量 */
struct Vector2D {
    var x = 0.0,y: -vector.y)
}

func += (inout left: Vector2D,right: Vector2D) {
    left = left + right
}

prefix func ++ (inout vector: Vector2D) -> Vector2D {
    vector += Vector2D(x: 1.0,y: 1.0)
    return vector
}

var a = Vector2D(x: 1.0,y: 2.1)
let b = Vector2D(x: 2.4,y: 6.6)
a += b
print(a)    // Vector2D(x: 3.4,y: 8.7)

print(++a)  // Vector2D(x: 4.4,y: 9.7)

等价运算符

自定义的类和结构体没有对等价运算符进行默认实现，等价运算符通常被称为“相等”运算符（==）与“不等”运算符（!=）。对于自定义类型，Swift无法判断其是否“相等”，因为“相等”的含义取决于这些自定义类型在你的代码中所扮演的角色。

为了使用等价运算符能对自定义的类型进行判等运算，需要为其提供自定义实现，实现的方法与其它中缀运算符一样。

/**
 * 二维坐标向量
 */
struct Vector2D {
    var x = 0.0,y = 0.0
}

func + (left: Vector2D,right: Vector2D) -> Vector2D {
    return Vector2D(x: left.x + right.x,y: left.y + right.y)
}

prefix func - (vector: Vector2D) -> Vector2D {
    return Vector2D(x: -vector.x,y: -vector.y)
}

func += (inout left: Vector2D,right: Vector2D) {
    left = left + right
}

prefix func ++ (inout vector: Vector2D) -> Vector2D {
    vector += Vector2D(x: 1.0,y: 1.0)
    return vector
}

func == (left: Vector2D,right: Vector2D) -> Bool {
    return left.x == right.x && left.y == right.y
}

func != (left: Vector2D,right: Vector2D) -> Bool {
    return !(left == right)
}

var a = Vector2D(x: 1.0,y: 2.1)
let b = Vector2D(x: 2.4,y: 6.6)
let c = Vector2D(x: 2.4,y: 6.6)
print(a != c)   // true
print(b == c)   // true

自定义运算符

除了实现标准运算符，在Swift中还可以声明和实现自定义运算符。可以用来自定义运算符的字符列表请参考运算符，原文在Lexical Structure中的Operators小节。

新的运算符先要使用operator关键字***在全局作用域内进行定义***，同时还要指定prefix`infix或者postfix修饰符。

/**
 * 二维坐标向量
 */
struct Vector2D {
    var x = 0.0,right: Vector2D) -> Bool {
    return !(left == right)
}

prefix operator +++ {}  // 定义了一个新的名为+++的前缀运算符

prefix func +++ (inout vector: Vector2D) -> Vector2D {  // 此处，+++被实现为“前缀双自增”运算符
    vector += vector
    return vector
}

var a = Vector2D(x: 1.0,y: 2.1)
print(+++a)   // Vector2D(x: 2.0,y: 4.2)

自定义中缀运算符的优先级和结合性

自定义的中缀运算符也可以指定优先级和结合性。

结合性可取的值有left，right和none。当左结合运算符跟其他相同优先级的左结合运算符写在一起时，会跟左边的值进行结合。同理，当右结合运算符跟其他相同优先级的右结合运算符写在一起时，会跟右边的值进行结合。而非结合运算符不能跟其他相同优先级的运算符写在一起。

结合性的默认值是none，优先级的默认值100。

/**
 * 二维坐标向量
 */
struct Vector2D {
    var x = 0.0,right: Vector2D) -> Bool {
    return !(left == right)
}

prefix operator +++ {}  // 定义了一个新的名为+++的前缀运算符

prefix func +++ (inout vector: Vector2D) -> Vector2D {  // 此处，+++被实现为“前缀双自增”运算符
    vector += vector
    return vector
}

infix operator +- { associativity left precedence 140 }

func +- (left: Vector2D,y: left.y - right.y)
}

var a = Vector2D(x: 1.0,y: 6.6)
let c = a +- b
print(c)    // Vector2D(x: 3.4,y: -4.5)

上面的代码中，将它的结合性和优先级被分别设置为left和140，这与+和-等默认的中缀“相加型”运算符是相同的。关于Swift标准库提供的运算符的结合性与优先级，请参考Swift Standard Library Operators Reference。

注意，当定义前缀与后缀运算符的时候，我们并没有指定优先级。然而，如果对同一个值同时使用前缀与后缀运算符，则后缀运算符会先参与运算。

至此，Swift的语法介绍完毕。

下面是其他一些有用的参考，供以后详细查阅。苹果官方实时保持更新。

• Swift Standard Library Reference
• Swift Standard Library Functions Reference
• Swift Standard Library Operators Reference
• Swift Standard Library Type Aliases Reference

Bye. ??????