// UInt8 类型的整数有 8 个比特位,可以存储 0 ~ 255 之间的任意整数
let initialBits: UInt8 = 0b00001111 // 这个值等价于十进制的 15
/* 即所有的 0 都变成了 1,同时所有的 1 都变成 0
invertedBits 的二进制值为 11110000,等价于无符号十进制数的 240
*/
let invertedBits = ~initialBits // 等于 0b11110000
/*
firstSixBits 和 lastSixBits 中间 4 个位的值都为 1
使用按位与运算符之后,得到二进制数值 00111100
等价于无符号十进制数的 60
*/
let firstSixBits: UInt8 = 0b11111100
let lastSixBits: UInt8 = 0b00111111
let middleFourBits = firstSixBits & lastSixBits // 等于 00111100
/*
someBits 和 moreBits 存在不同的位被设置为 1
使用按位或运算符之后,得到二进制数值 11111110
等价于无符号十进制数的 254
*/
let someBits: UInt8 = 0b10110010
let moreBits: UInt8 = 0b01011110
let combinedbits = someBits | moreBits // 等于 11111110
/*
firstBits 和 otherBits 都有一个自己为 1,而对方为 0 的位
按位异或运算符将新数的这两个位都设置为 1
在其余的位上 firstBits 和 otherBits 是相同的,所以设置为 0
*/
let firstBits: UInt8 = 0b00010100
let otherBits: UInt8 = 0b00000101
let outputBits = firstBits ^ otherBits // 等于 00010001
下面的代码演示了 Swift 中的移位运算:展示了 11111111 << 1(即把 11111111 向左移动 1 位),和 11111111 >> 1(即把 11111111 向右移动 1 位)的结果。
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
这个示例使用了一个命名为 pink 的 UInt32 型常量来存储 Cascading Style Sheets(CSS)中粉色的颜色值。
该 CSS 的颜色值 #CC6699,在 Swift 中表示为十六进制的 0xCC6699。
然后利用按位与运算符(&)和按位右移运算符(>>)从这个颜色值中分解出红(CC)、绿(66)以及蓝(99)三个部分。
红色部分是通过对 0xCC6699 和 0xFF0000 进行按位与运算后得到的
0xFF0000 中的 0 部分“掩盖”了 OxCC6699 中的第二、第三个字节,使得数值中的 6699 被忽略,只留下 0xCC0000。
然后,将这个数向右移动 16 位(>> 16)。十六进制中每两个字符占用 8 个比特位,所以移动 16 位后 0xCC0000 就变为 0x0000CC。这个数和 0xCC 是等同的,也就是十进制数值的 204。
同样的,绿色部分通过对 0xCC6699 和 0x00FF00 进行按位与运算得到 0x006600。然后将这个数向右移动 8 位,得到 0x66,也就是十进制数值的 102。
最后,蓝色部分通过对 0xCC6699 和 0x0000FF 进行按位与运算得到 0x000099。这里不需要再向右移位,而 0x000099 也就是 0x99 ,也就是十进制数值的 153。
由于正数和负数的特殊存储方式,在对它们进行右移的时候,会使它们越来越接近 0。
在移位的过程中保持符号位不变,意味着负整数在接近 0 的过程中会一直保持为负。
var potentialOverflow = Int16.max
// potentialOverflow 的值是 32767,这是 Int16 能容纳的最大整数
potentialOverflow += 1
// 这里会报错
// unsignedOverflow 被初始化为 UInt8 所能容纳的最大整数(255,以二进制表示即 11111111)
var unsignedOverflow = UInt8.max // unsignedOverflow 等于 UInt8 所能容纳的最大整数 255
/*
使用溢出加法运算符(&+)对其进行加 1 运算
这使得它的二进制表示正好超出 UInt8 所能容纳的位数,也就导致了数值的溢出
*/
unsignedOverflow = unsignedOverflow &+ 1 // 此时 unsignedOverflow 等于 0
// UInt8 型整数能容纳的最小值是 0,以二进制表示即 00000000
var unsignedOverflow = UInt8.min // unsignedOverflow 等于 UInt8 所能容纳的最小整数 0
// 当使用溢出减法运算符对其进行减 1 运算时
// 数值会产生下溢并被截断为 11111111, 也就是十进制数值的 255
unsignedOverflow = unsignedOverflow &- 1 // 此时 unsignedOverflow 等于 255
// Int8 型整数能容纳的最小值是 -128,以二进制表示即 10000000
var signedOverflow = Int8.min // signedOverflow 等于 Int8 所能容纳的最小整数 -128
/*
当使用溢出减法运算符对其进行减 1 运算时,
符号位被翻转,得到二进制数值 01111111,也就是十进制数值的 127
这个值也是 Int8 型整所能容纳的最大值
*/
signedOverflow = signedOverflow &- 1 // 此时 signedOverflow 等于 127
2 + 3 % 4 * 5 // 结果是 17
2 + ((3 % 4) * 5)
// (3 % 4) 等于 3,所以表达式相当于:
2 + (3 * 5)
//3 * 5 等于 15,所以表达式相当于:
2 + 15
//因此计算结果为 17。
// 一个名为 Vector2D 的结构体用来表示二维坐标向量 (x, y)
struct Vector2D {
var x = 0.0, y = 0.0
}
// 一个可以将两个 Vector2D 结构体实例进行相加的运算符函数
extension Vector2D {
static func + (left: Vector2D, right: Vector2D) -> Vector2D {
return Vector2D(x: left.x + right.x, y: left.y + right.y)
}
}
该运算符函数被定义为 Vector2D 上的一个类方法,并且函数的名字与它要进行重载的 + 名字一致。
因为加法运算并不是一个向量必需的功能,所以这个类方法被定义在 Vector2D 的一个扩展中,而不是 Vector2D 结构体声明内。
而算术加法运算符是二元运算符,所以这个运算符函数接收两个类型为 Vector2D 的参数,同时有一个 Vector2D 类型的返回值。
在这个实现中,输入参数分别被命名为 left 和 right,代表在 + 运算符左边和右边的两个 Vector2D 实例。
函数返回了一个新的 Vector2D 实例,这个实例的 x 和 y 分别等于作为参数的两个实例的 x 和 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)
extension Vector2D {
static prefix func - (vector: Vector2D) -> Vector2D {
return Vector2D(x: -vector.x, y: -vector.y)
}
}
这段代码为 Vector2D 类型实现了一元运算符(-a)。由于该运算符是前缀运算符,所以这个函数需要加上 prefix 修饰符。
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 实例
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 的值现在为 (4.0, 6.0)
注意
1. 不能对默认的赋值运算符(=)进行重载。只有复合赋值运算符可以被重载。
2. 同样地,也无法对三元条件运算符 (a ? b : c) 进行重载。
extension Vector2D: Equatable {
static func == (left: Vector2D, right: Vector2D) -> Bool {
return (left.x == right.x) && (left.y == right.y)
}
}
上述代码实现了“相等”运算符( = = ) 来判断两个 Vector2D 实例是否相等。
对于 Vector2D 来说,“相等”意味着“两个实例的 x 和 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.")
}
// 打印“These two vectors are equivalent.”
struct Vector3D: Equatable {
var x = 0.0, y = 0.0, z = 0.0
}
let twoThreeFour = Vector3D(x: 2.0, y: 3.0, z: 4.0)
let anotherTwoThreeFour = Vector3D(x: 2.0, y: 3.0, z: 4.0)
if twoThreeFour == anotherTwoThreeFour {
print("These two vectors are also equivalent.")
}
// 打印“These two vectors are also equivalent.”
prefix operator +++
上面的代码定义了一个新的名为 +++ 的前缀运算符。
对于这个运算符,在 Swift 中并没有已知的意义,因此在针对 Vector2D 实例的特定上下文中,给予了它自定义的意义。
对这个示例来讲,+++ 被实现为“前缀双自增”运算符。
它使用了前面定义的复合加法运算符来让矩阵与自身进行相加,从而让 Vector2D 实例的 x 属性和 y 属性值翻倍。
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 现在的值为 (2.0, 8.0)
// afterDoubling 现在的值也为 (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 是一个 Vector2D 实例,并且它的值为 (4.0, -2.0)
这个运算符把两个向量的 x 值相加,同时从第一个向量的 y 中减去第二个向量的 y 。
因为它本质上是属于“相加型”运算符,所以将它放置在 + 和 - 等默认中缀“相加型”运算符相同的优先级组中。
注意
1. 当定义前缀与后缀运算符的时候,我们并没有指定优先级。
2. 然而,如果对同一个值同时使用前缀与后缀运算符,则后缀运算符会先参与运算。