目录

[toc]

位运算符

1. 按位取反运算符~

let initialBits: UInt8 = 0b00001111
let invertedBits = ~initialBits      //等于 11110000

2. 按位与运算符&

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

3. 按位或运算符|

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

4. 按位异或运算符^

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

5. 按位左移<<、右移运算符>>

1. 无符号整数的移位运算

一个正数的原码、反码、补码都是它的二进制表现形式。(无符号数没有原码、反码和补码一说。只有带符号数才存在不同的编码方式。)

规则如下：

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

let shiftBits: UInt8 = 4             // 00000100
shiftBits << 1                       // 00001000
shiftBits << 2                       // 00010000
shiftBits << 5                       // 10000000
shiftBits << 6                       // 00000000
shiftBits >> 2                       // 00000001

使用移位运算对颜色进行RGB分解

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

2. 有符号整数的移位运算

一个负数的原码是首位为1的二进制数。反码是符号位不变，其他位取反。补码是反码加1。

二进制的第一位是符号位，0代表整数，1代表负数。

let shiftBits: Int8 = -4        // 11111100
_ = shiftBits << 1              // 11111000
_ = shiftBits << 2              // 11110000
_ = shiftBits << 5              // 10000000
_ = shiftBits << 6              // 00000000
_ = shiftBits >> 2              // 11111111

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

溢出运算符

在默认情况下，当向一个整数赋予超过它容量的值时，Swift默认会报错，而不是生成一个无效的数。

// potentialOverflow 的值是 32767，这是 Int16 能容纳的最大整数
var potentialOverflow = Int16.max           
//potentialOverflow += 1                    // 这里会报错
// 可以选择让系统在数值溢出的时候采取截断处理，而非报错。 `&+` `&-` `&*`
var unsignedOverflow = UInt8.max            // unsignedOverflow 等于 UInt8 所能容纳的最大整数 255 
unsignedOverflow = unsignedOverflow &+ 1    // 此时 unsignedOverflow 等于 0
var unsignedOverflow2 = UInt8.min           // unsignedOverflow 等于 UInt8 所能容纳的最小整数 0
unsignedOverflow2 = unsignedOverflow2 &- 1  // 此时 unsignedOverflow 等于 255

优先级和结合性

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

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

运算符函数

运算符重载: 类和结构体可以为现有的运算符提供自定义的实现。
例子：向量的相加

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)
    }
    static prefix func - (vector: Vector2D) -> Vector2D {
        return Vector2D(x: -vector.x, y: -vector.y)
    }
    static func += (left: inout Vector2D, right: Vector2D) {
        left = left + right
    }
    static func == (left: Vector2D, right: Vector2D) -> Bool {
        return (left.x == right.x) && (left.y == right.y)
    }
    static func != (left: Vector2D, right: Vector2D) -> Bool {
        return !(left == right)
    }
}
let vector = Vector2D(x: 3.0, y: 1.0)
let anotherVector = Vector2D(x: 2.0, y: 4.0)
// combinedVector 是一个新的 Vector2D 实例，值为 (5.0, 5.0)
let combinedVector = vector + anotherVector  
// negative 是一个值为 (-3.0, -1.0) 的 Vector2D 实例
let negative = -vector                       
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)
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.")
}

自定义运算符

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)

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)