《swift2.0 官方教程中文版》 第2章-25高级运算符

import Foundation

/*位运算符***********************************************/

//按位取反运算符

//按位取反运算符( ~ ) 可以对一个数值的全部位进行取反:

//按位取反操作符是一个前置运算符,需要直接放在操作数的之前,并且它们之间不能添加任何空格。

let initialBits: UInt8 = 0b00001111

let invertedBits = ~initialBits

// 等于 0b11110000

//按位与运算符

//按位与运算符( & )可以对两个数的比特位进行合并。它返回一个新的数,只有当两个操作数的对应位都为 1 的 时候,该数的对应位才为 1 。

let firstSixBits: UInt8 = 0b11111100

let lastSixBits: UInt8 = 0b00111111

let middleFourBits = firstSixBits & lastSixBits

// 等于 00111100

//按位或运算符

//按位或运算符( | )可以对两个数的比特位进行比较。它返回一个新的数,只要两个操作数的对应位中有任意一个为 1 时,该数的对应位就为 1 。

let someBits: UInt8 = 0b10110010

let moreBits: UInt8 = 0b01011110

let combinedbits = someBits | moreBits

// 等于 11111110

//按位异或运算符

//按位异或运算符( ^ )可以对两个数的比特位进行比较。它返回一个新的数,当两个操作数的对应位不相同时,该 数的对应位就为 1 :

let firstBits: UInt8 = 0b00010100

let otherBits: UInt8 = 0b00000101

let outputBits = firstBits ^ otherBits

// 等于 00010001

//按位左移/右移运算符

//按位左移运算符( << )和按位右移运算符( >> )可以对一个数进行指定位数的左移和右移,但是需要遵守下面定义的规则。

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

//对无符号整型进行移位的规则如下:

//1. 已经存在的比特位按指定的位数进行左移和右移。

//2. 任何移动超出整型存储边界的位都会被丢弃。

//3. 用 0 来填充移动后产生的空白位。

//这种方法称为逻辑移位( logical shift )。

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

print("redComponent is \(redComponent)")

let greenComponent = (pink & 0x00FF00) >> 8 // greenComponent 是 0x66,即 102

print("greenComponent is \(greenComponent)")

let blueComponent = pink & 0x0000FF // blueComponent 是 0x99,即 153

print("blueComponent is \(blueComponent)")

//这个示例使用了一个命名为 pink 的 UInt32 型常量来存储层叠样式表( CSS )中粉色的颜色值。该 CSS 的十 六进制颜色值 #CC6699,在 Swift 中表示为 0xCC6699 。然后利用按位与运算符( & )和按位右移运算符( >> )从这个颜色值中分解出红( CC )、绿( 66 )以及蓝( 99 )三个部分。

//有符号整数使用第 1 个比特位(通常被称为符号位)来表示这个数的正负。符号位为 0 代表正数,为 1 代表负 数。

//符号位为 0,说明这是一个正数,另外 7 位则代表了十进制数值 4 的二进制表示。

//负数的存储方式略有不同。它存储的是 2 的 n 次方减去它的真实值绝对值,这里的 n 为数值位的位数。一个 8 位的数有 7 个数值位,所以是 2 的 7 次方,即 128。

/*溢出运算符***********************************************/

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

//例如,Int16 型整数能容纳的有符号整数范围是 -32768 到 32767,当为一个 Int16 型变量赋的值超过这个 范围时,系统就会报错:

var potentialOverflow = Int16.max

// potentialOverflow 的值是 32767,这是 Int16 能容纳的最大整数

//potentialOverflow += 1

// 这里会报错

//溢出加法 &+

//溢出减法 &-

//溢出乘法 &*

var unsignedOverflow = UInt8.max

// unsignedOverflow 等于 UInt8 所能容纳的最大整数 255

unsignedOverflow = unsignedOverflow &+ 1

print("unsignedOverflow is \(unsignedOverflow)")

// 此时 unsignedOverflow 等于 0

unsignedOverflow = UInt8.min

// unsignedOverflow 等于 UInt8 所能容纳的最小整数 0

unsignedOverflow = unsignedOverflow &- 1

print("unsignedOverflow is \(unsignedOverflow)")

// 此时 unsignedOverflow 等于 255

var signedOverflow = Int8.min

// signedOverflow 等于 Int8 所能容纳的最小整数 -128

signedOverflow = signedOverflow &- 1

print("signedOverflow is \(signedOverflow)")

// 此时 signedOverflow 等于 127

/*优先级和结合性***********************************************/

/*运算符函数***********************************************/

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)

}

//该运算符函数被定义为一个全局函数,并且函数的名字与它要进行重载的 + 名字一致。因为算术加法运算符是 双目运算符,所以这个运算符函数接收两个类型为 Vector2D 的输入参数,同时有一个 Vector2D 类型的返回 值。

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)

//要实现前缀或者后缀运算符,需要在声明运算符函数的时候在 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 实例

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)

prefix func ++ (inout vector: Vector2D) -> Vector2D {

vector += Vector2D(x: 1.0,y: 1.0)

return vector

}

var toIncrement = Vector2D(x: 3.0,y: 4.0)

let afterIncrement = ++toIncrement

// toIncrement 的值现在为 (4.0,5.0)

// afterIncrement 的值同样为 (4.0,5.0)

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

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.")

}

// prints "These two vectors are equivalent."

prefix operator +++ {}

prefix func +++ (inout vector: Vector2D) -> Vector2D {

vector += vector

return vector

}

var toBeDoubled = Vector2D(x: 1.0,y: 4.0)

let afterDoubling = +++toBeDoubled

print("\(toBeDoubled) \(afterDoubling)")

// toBeDoubled 现在的值为 (2.0,8.0)

// afterDoubling 现在的值也为 (2.0,8.0)

//结合性( associativity )的默认值是 none,优先级( precedence )如果没有指定,则默认为 100 。

//以下例子定义了一个新的中缀运算符 +-,此操作符是左结合的,并且它的优先级为 140 :

infix operator +- { associativity left precedence 140 }

func +- (left: Vector2D,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

print("plusMinusVector is \(plusMinusVector)")

// plusMinusVector 是一个 Vector2D 类型,并且它的值为 (4.0,-2.0)

//注意: 当定义前缀与后缀操作符的时候,我们并没有指定优先级。然而,如果对同一个操作数同时使用前缀与 后缀操作符,则后缀操作符会先被执行。