位运算符（Bitwise Operators）
- 位运算符可以操作数据结构中每个独立的比特位。它们通常被用在底层开发中，比如图形编程和创建设备驱动。位运算符在处理外部资源的原始数据时也十分有用，比如对自定义通信协议传输的数据进行编码和解码。
按位取反运算符（Bitwise NOT Operator）
按位取反运算符（~）可以对一个数值的全部比特位进行取反
按位取反运算符是一个前缀运算符，需要直接放在运算的数之前，并且它们之间不能添加任何空格。
let initialBits: UInt8 = 0b00001111
let invertedBits = ~initialBits // 等于 0b11110000
按位与运算符（Bitwise AND Operator）
- 按位与运算符（&）可以对两个数的比特位进行合并。它返回一个新的数，只有当两个数的对应位都为 1的时候，新数的对应位才为 1。
let firstSixBits: UInt8 = 0b11111100
let lastSixBits: UInt8 = 0b00111111
let middleFourBits = firstSixBits & lastSixBits // 等于 00111100
按位或运算符（Bitwise OR Operator）
- 按位或运算符（|）可以对两个数的比特位进行比较。它返回一个新的数，只要两个数的对应位中有任意一个为 1时，新数的对应位就为 1。
let someBits: UInt8 = 0b10110010
let moreBits: UInt8 = 0b01011110
let combinedbits = someBits | moreBits // 等于 11111110
按位异或运算符（Bitwise XOR Operator）
- 按位异或运算符（^）可以对两个数的比特位进行比较。它返回一个新的数，当两个数的对应位不相同时，新数的对应位就为 1。
let firstBits: UInt8 = 0b00010100
let otherBits: UInt8 = 0b00000101
let outputBits = firstBits ^ otherBits // 等于 00010001
按位左移、右移运算符（Bitwise Left and Right Shift Operators）
按位左移运算符（<<）和按位右移运算符（>>）可以对一个数的所有位进行指定位数的左移和右移。
对一个数进行按位左移或按位右移，相当于对这个数进行乘以 2 或除以 2 的运算。将一个整数左移一位，等价于将这个数乘以 2，同样地，将一个整数右移一位，等价于将这个数除以 2。
无符号整数的移位运算（Shifting Behavior for Unsigned Integers）
- 已经存在的位按指定的位数进行左移和右移。
- 任何因移动而超出整型存储范围的位都会被丢弃。
- 用 0来填充移位后产生的空白位。
这种方法称为逻辑移位。
let shiftBits: UInt8 = 4 // 即二进制的 00000100
shiftBits << 1 // 00001000
shiftBits << 2 // 00010000
shiftBits << 5 // 10000000
shiftBits << 6 // 00000000
shiftBits >> 2 // 00000001
let pink: UInt32 = 0xCC6699
let redComponent = (pink & 0xFF0000) >> 16 // redComponent 是 0xCC，即 204
let greenComponent = (pink & 0x00FF00) >> 8 // greenComponent 是 0x66， 即 102
let blueComponent = pink & 0x0000FF // blueComponent 是 0x99，即 153
有符号整数的移位运算（Shifting Behavior for Signed Integers）
当对整数进行按位右移运算时，遵循与无符号整数相同的规则，但是对于移位产生的空白位使用符号位进行填充，而不是用 0。
由于正数和负数的特殊存储方式，在对它们进行右移的时候，会使它们越来越接近 0。在移位的过程中保持符号位不变，意味着负整数在接近 0的过程中会一直保持为负。
溢出运算符（Overflow Operators）
可以选择让系统在数值溢出的时候采取截断处理，而非报错。可以使用 Swift 提供的三个溢出运算符来让系统支持整数溢出运算。这些运算符都是以 &开头的
- 溢出加法 &+
- 溢出减法 &-
- 溢出乘法 &*
数值溢出（Value Overflow）
数值有可能出现上溢或者下溢。
溢出也会发生在有符号整型数值上。在对有符号整型数值进行溢出加法或溢出减法运算时，符号位也需要参与计算。
对于无符号与有符号整型数值来说，当出现上溢时，它们会从数值所能容纳的最大数变成最小的数。同样地，当发生下溢时，它们会从所能容纳的最小数变成最大的数。
var unsignedOverflow = UInt8.max
// unsignedOverflow 等于 UInt8 所能容纳的最大整数 255
unsignedOverflow = unsignedOverflow &+ 1
// 此时 unsignedOverflow 等于 0
var unsignedOverflow1 = UInt8.min
// unsignedOverflow1 等于 UInt8 所能容纳的最小整数 0
unsignedOverflow1 = unsignedOverflow1 &- 1
// 此时 unsignedOverflow1 等于 255
var signedOverflow = Int8.min
// signedOverflow 等于 Int8 所能容纳的最小整数 -128
signedOverflow = signedOverflow &- 1
// 此时 signedOverflow 等于 127
优先级和结合性（Precedence and Associativity）
运算符的优先级使得一些运算符优先于其他运算符，高优先级的运算符会先被计算。
结合性定义了相同优先级的运算符是如何结合的，也就是说，是与左边结合为一组，还是与右边结合为一组。
运算符函数（Operator Functions）
- 类和结构体可以为现有的运算符提供自定义的实现，这通常被称为运算符重载。
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 vector = Vector2D(x: 3.0, y: 1.0)
let anotherVector = Vector2D(x: 2.0, y: 4.0)
let combinedVector = vector + anotherVector
// combinedVector 是一个新的 Vector2D 实例，值为 (5.0, 5.0)
前缀和后缀运算符（Prefix and Postfix Operators）
类与结构体也能提供标准单目运算符的实现。
要实现前缀或者后缀运算符，需要在声明运算符函数的时候在 func关键字之前指定 prefix或者 postfix修饰符
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 是一个值为 (-3.0, -4.0) 的 Vector2D 实例
let alsoPositive = -negative
// alsoPositive 是一个值为 (3.0, 4.0) 的 Vector2D 实例
复合赋值运算符（Compound Assignment Operators）
复合赋值运算符将赋值运算符（=）与其它运算符进行结合。例如，将加法与赋值结合成加法赋值运算符（+=）。
在实现的时候，需要把运算符的左参数设置成 inout类型，因为这个参数的值会在运算符函数内直接被修改。
不能对默认的赋值运算符（=）进行重载。只有组合赋值运算符可以被重载。
无法对三目条件运算符 （a ? b : c） 进行重载。
func += (inout left: 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 的值现在为 (4.0, 6.0)
等价运算符（Equivalence Operators）
自定义的类和结构体没有对等价运算符进行默认实现，等价运算符通常被称为“相等”运算符（==）与“不等”运算符（!=）。对于自定义类型，Swift 无法判断其是否“相等”，因为“相等”的含义取决于这些自定义类型在代码中所扮演的角色。
为了使用等价运算符能对自定义的类型进行判等运算，需要为其提供自定义实现。
func == (left: Vector2D, right: Vector2D) -> Bool {
return (left.x == right.x) && (left.y == right.y)
}
func != (left: Vector2D, right: Vector2D) -> Bool {
return !(left == right)
}
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.")
}
// 打印 “These two vectors are equivalent.”
自定义运算符（Custom Operators）
除了实现标准运算符，在 Swift 中还可以声明和实现自定义运算符。
新的运算符要使用 operator关键字在全局作用域内进行定义，同时还要指定 prefix、infix或者 postfix修饰符
prefix operator +++ {}
prefix func +++ (inout vector: Vector2D) -> Vector2D {
vector += vector
return vector
}
var toBeDoubled = Vector2D(x: 1.0, y: 4.0)
let afterDoubling = +++toBeDoubled
// toBeDoubled 现在的值为 (2.0, 8.0)
// afterDoubling 现在的值也为 (2.0, 8.0)
自定义中缀运算符的优先级和结合性（Precedence and Associativity for Custom Infix Operators）
自定义的中缀运算符也可以指定优先级和结合性。
结合性可取的值有left，right和 none。
结合性的默认值是 none，优先级的默认值 100。
当定义前缀与后缀运算符的时候，我们并没有指定优先级。然而，如果对同一个值同时使用前缀与后缀运算符，则后缀运算符会先参与运算。
infix operator +- { associativity left precedence 140 }
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 是一个 Vector2D 实例，并且它的值为 (4.0, -2.0)
- 赋值运算符=不能重载，其实就是复制。可以通过协议的方式实现，比如考虑遵循NSCopying协议
- 运算符重载函数都是全局函数，不要拘泥于“面向对象的设计方法”了。这些函数放在类或者结构体、枚举同一个源文件中，但是写在{}之外。
- 从理解的角度讲，运算符重载还是用全局函数的方式比较好。
- Swift兼容Object-C部分是面向对象，有动态特性的。但是Swift本身是静态的，类型安全的，没有动态特性。另外，也不全是面向对象的，像结构体，枚举，常用的集合等等，跟面向对象都没什么关系。编程的思路需要进一步拓展。
