Swift编程二十八(高级运算符)

2019-06-25  本文已影响0人  酒茶白开水

案例代码下载

高级运算符

除了基本运算符中描述的运算符之外,Swift还提供了几个执行更复杂值操作的高级运算符。这些包括C和Objective-C中熟悉的所有按位和位移运算符。

与C中的算术运算符不同,Swift中的算术运算符默认不会溢出。溢出行为被捕获并报告为错误。要选择溢出行为,请使用Swift默认溢出的第二组算术运算符,例如溢出加法运算符(&+)。所有这些溢出运算符都以&符号开头。

定义自己的结构,类和枚举时,为这些自定义类型提供自己的标准Swift运算符实现会很有用。Swift可以轻松地为这些运算符提供定制的实现,并确切地确定它们对创建的每种类型的行为。

不仅限于预定义的运算符。Swift为提供了自定义中缀,前缀,后缀和赋值运算符的自由,具有自定义优先级和关联性。这些运算符可以像任何预定义的运算符一样在代码中使用和采用,甚至可以扩展现有类型以支持定义的自定义运算符。

按位运算符

按位运算符可以处理数据结构中的各个原始数据位。它们通常用于低级编程,例如图形编程和设备驱动程序创建。当使用来自外部源的原始数据时,按位运算符也很有用,例如编码和解码数据以通过自定义协议进行通信。

Swift支持C中的所有按位运算符,如下所述。

按位NOT运算符

该位NOT运算符(~)反转数所有位:


image

按位NOT运算符是一个前缀运算符,它出现在它操作的值之前,没有任何空格:

let initialBits: UInt8 = 0b00001111
let invertedBits = ~initialBits

UInt8整数有八位,可以存储0和255之间的任何值。此示例使用二进制值初始化一个UInt8整数,该二进制值00001111的前四位设置为0,其后四位设置为1。这相当于十进制值15。

然后使用按位NOT运算符创建一个新的常量invertedBits,该常量等于initialBits,但所有位都被反转。0成为1,1成为0。invertedBitsis的值11110000等于无符号十进制值240。

按位AND运算符

按位AND运算符(&)结合了两个数字的位数。它返回一个新的号码,仅当位两个输入数字在其位等于1才被设置为1:


image

在下面的例子中,firstSixBits和lastSixBits两个值具有四个中间位等于1。按位AND运算符将它们组合起来以产生数字00111100,该数字等于无符号十进制值60:

let firstSixBits: UInt8 = 0b11111100
let lastSixBits: UInt8 = 0b00111111
let middleFourBits = firstSixBits & lastSixBits

按位OR运算符

按位或运算符(|)对两个数的二进制位进行比较。运算符返回一个新数字,如果任一输入数的位等于1其位设置为1:


image

在下面的例子中,someBits和moreBits的值具有不同的位设置为1。按位OR运算符将它们组合起来以产生数字11111110,该数字等于无符号数254:

let someBits: UInt8 = 0b10110010
let moreBits: UInt8 = 0b01011110
let combinedbits = someBits | moreBits

按位异或运算符

的按位异或运算符,或“异或运算符”( ^),比较两个数的位。运算符返回一个新数字,输入位不同其位设置为1,输入位相同其位设置为0:


image

在下面的示例中,firstBits和otherBits一个值位为1,而另一个不是,按位异或运算符这个位设置1为其输出值。firstBits和otherBits所有其他位相同在输出值中设置为0:

let firstBits: UInt8 = 0b00010100
let otherBits: UInt8 = 0b00000101
let outputBits = firstBits ^ otherBits

按位左右移位运算符

在按位左移位运算符(<<)和按位右移位运算符(>>)中的数向左或向移动一个数的所有特定数量的位,根据下面定义的规则。

按位左右移位具有将整数乘以或除以因子2的效果。将整数位向左移动一个位置会使其值加倍,而将其向右移动一个位置会使其值减半。

无符号整数的移位行为

无符号整数的位移行为如下:

  1. 现有位按所请求的位数向左或向右移动。
  2. 移除超出整数存储边界的任何位都将被丢弃。
  3. 在原始位向左或向右移动之后,将零插入到留下的空间中。

这种方法被称为逻辑转换。

下图显示了11111111 << 1(11111111按位向左移动1)和11111111 >> 1(11111111按位向右移动1)的结果。移动蓝色数字,丢弃灰色数字,并插入橙色零:


image

以下是Swift代码中位移的方式:

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

此示例使用一个UInt32常量叫做pink来存储颜色层叠样式表的粉红色颜色值。CSS颜色值#CC6699写0xCC6699在Swift的十六进制数字表示中。然后通过按位AND运算符(&)和按位右移运算符(>>)将此颜色分解为其红色(CC),绿色(66)和蓝色(99)分量。

通过在数字0xCC6699和0xFF0000之间执行按位AND来获得红色分量。0xFF0000的0有效地“掩盖”0xCC6699第二个和第三个字节,导致6699被忽略返回0xCC0000。

然后将此数字向右移动16位(>> 16)。十六进制数中的每对字符使用8位,因此向右移动16位将0xCC0000转换为0x0000CC。这与0xCC相同十进制值204。

类似地,绿色成分通过0xCC6699和0x00FF00之间执行按位与数字获得,其给出的输出值0x006600。然后将此输出值向右移动8位,给出一个值0x66,其值为十进制值102。

最后,将蓝色成分是通过数字0xCC6699和0x0000FF之间执行按位与获得,其给出的输出值0x000099。没有必要将它向右移动,因为0x000099等于0x99,其十进制值为153。

有符号整数的移位行为

对于有符号整数而言,移位行为比无符号整数更复杂,因为有符号整数用二进制表示。(为简单起见,下面的示例基于8位有符号整数,但相同的原则适用于任何大小的有符号整数。)

有符号整数使用它们的第一位(称为符号位)来指示整数是正还是负。符号位0表示正数,符号1表示负数。

其余位(称为值位)存储实际值。正数以与无符号整数完全相同的方式存储,从0向上计数。以下是数字4的Int8位数:


image

符号位是0(意思是“正”),七个值位是用二进制表示法写的数字4。

但是,负数以不同方式存储。它们的存储方式是将它们的绝对值减去2的n次方,其中n是值的位数。一个八比特数有七个值的位,所以这意味着2的7次方,即128。

以下是Int8查找数字的位数-4:


image

这一次,符号位是1(意思是“负”),七个值位的二进制值为124(即128 - 4):


image

负数的这种编码称为二进制补码表示。这似乎是一种代表负数的不寻常方式,但它有几个优点。

首先,可以-1加-4,简单地通过执行一个标准二进制加法全部八个位(包括符号位),并丢弃任何不适合8位,一旦完成:


image

其次,二进制补码表示还可以将负数位向左和向右移动,就像正数一样,并且对于向左移动的每一个移位最终都会将它们加倍,或者对于向右移动的每个位将它们减半。 。当有符号整数右移,适用无符号整数相同的规则,但在剩下的填充任何空位:要做到这一点,整数右移使用符号位补位,而不是零。


image

此操作可确保有符号整数在向右移动后具有相同的符号,并称为算术移位。

由于存储正数和负数的特殊方式,将它们中的任何一个向右移动都会使它们接近零。在此移位期间保持符号位相同意味着负整数向0移动保持为负值。

溢出运算符

如果尝试将数字插入到不能保存该值的整数常量或变量中,默认情况下Swift会报告错误,而不是允许创建无效值。当处理太大或太小的数字时,此行为可提供额外的安全性。

例如,Int16整数类型可以包含-32768和32767之间的任何有符号整数。尝试将Int16常量或变量设置为此范围之外的数字会导致错误:

var potentialOverflow = Int16.max
potentialOverflow += 1

当值变得太大或太小时提供错误处理,在编码边界值条件时提供更大的灵活性。

但是,如果特别希望溢出条件截断可用位数,则可以选择此行为而不是触发错误。Swift提供了三个算术溢出运算符,它们选择加入整数计算的溢出行为。这些运算符都以&符号开头&:

值溢出

数字可以在正方向和负方向上溢出。

下面是使用overflow溢出加法(&+)允许无符号整数向正方向溢出时会发生什么的示例:

var unsignedOverflow = UInt8.max
unsignedOverflow = unsignedOverflow &+ 1

变量unsignedOverflow初始化为UInt8可以容纳的最大值(255或二进制11111111)。然后使用溢出加法运算符(&+)递增1。这使得它的二进制表示超出了UInt8可以容纳的大小,导致它溢出超出其边界,如下图所示。UInt8溢出添加后保留在范围内的值00000000为零。


image

当允许无符号整数向负方向溢出时会发生类似情况。这是使用溢出减法运算符(&-)的示例:

var unsignedOverflow = UInt8.min
unsignedOverflow = unsignedOverflow &- 1

UInt8可容纳的最小值为零或00000000二进制。如果使用溢出减法运算符(&-)从00000000减去1,这个数字将溢出并环绕到11111111,或十进制255。


image

对于有符号整数,也会发生溢出。有符号整数的所有加法和减法以按位方式执行,符号位作为加数或减数的一部分包括在内,如按位左右移位运算符中所述。

var signedOverflow = Int8.min
signedOverflow = signedOverflow &- 1

Int8最小值为-128或二进制10000000。使用溢出运算符从此二进制数中减去1得到二进制01111111,该值将切换符号位得出正数127,Int8即可容纳的最大正值。


image

对于有符号和无符号整数,正方向上的溢出从最大有效整数值回到最小值,而负方向上的溢出从最小值回到最大值。

优先级和相关性

运算符优先级使某些运算符的优先级高于其他, 那么首先计数优先级高的运算符。

运算符关联性定义了相同优先级的运算符如何组合在一起 - 从左侧分组,或从右侧分组。可以把它想象成“他们与左边的表达联系起来”或“他们将表达联系到他们的右边”。

在计算复合表达式的顺序时,考虑每个运算符的优先级和关联性非常重要。例如,运算符优先级解释了以下表达式等于17的原因。

2 + 3 % 4 * 5

如果从左到右严格阅读,可能表达式计算如下:

但是,实际答案17不是5。优先级较高的运算符在优先级较低的运算符之前进行求值。在Swift中,与在C中一样,余数运算符(%)和乘法运算符(*)的优先级高于加法运算符(+)。结果是在加法之前计数它们。

但是,余数和乘法具有相同的优先级。要得出确切计算顺序,还需要考虑它们的相关性。余数和乘法都与左边的表达式相关联。可以想象这是在表达式的这些部分周围添加隐式括号,从左边开始:

2 + ((3 % 4) * 5)

(3 % 4)是的3,所以这相当于:

2 + (3 * 5)

(3 * 5)是的15,所以这相当于:

2 + 15

这个计算得出了最终答案17。

有关Swift标准库提供的运算符的信息,包括运算符优先级组和相关性设置的完整列表,请参阅运算符声明。

注意

Swift的运算符优先级和关联性规则比C和Objective-C中的更简单,更可预测。但是,这意味着它们与基于C的语言不完全相同。在将现有代码移植到Swift时,请务必确保运算符交互的行为方式仍然符合预期。

运算符方法

类和结构可以提供自己的现有运算符实现。这称为重载现有运算符。

下面的示例显示了如何为自定义结构实现算术加法运算符(+)。算术加法运算符是一个二元运算符,因为它在两个目标上运行,并且被称为中缀,因为它出现在这两个目标之间。

该示例定义了二维位置向量(x, y)的结构Vector2D,然后定义了将Vector2D结构实例相加的运算符方法:

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)
    }
}

运算符方法被定义为Vector2D的一个类型方法,其方法名称与要重载的运算符(+)匹配。因为加法不是向量的基本行为的一部分,所以类型方法是在扩展Vector2D而不是在主结构声明中定义的Vector2D。因为算术加法运算符是二元运算符,所以此运算符方法接受两个Vector2D类型的输入参数,并返回单个输出值,也是类型Vector2D。

在此实现中,输入参数被命名left和right表示将位于+运算符左侧和右侧的Vector2D实例。该方法返回一个新Vector2D实例,其x和y属性被从两个Vector2D实例的x和y属性加到一起的总和初始化。

类型方法可以用作现有Vector2D实例之间的中缀运算符:

let vector = Vector2D(x: 3.0, y: 1.0)
let anotherVector = Vector2D(x: 2.0, y: 4.0)
let combinedVector = vector + anotherVector

此示例将向量加在一起并生成向量,如下所示。(3.0, 1.0)(2.0, 4.0)(5.0, 5.0)


image

前缀和后缀运算符

上面显示的示例演示了二元中缀运算符的自定义实现。类和结构还可以提供标准一元运算符的实现。一元运算符在单个目标上运行。如果它们位于其目标(如)之前,则它们是前缀,如果它们在目标之后(例如-a),则它们是后缀运算符(如b!)。

通过在声明运算符方法时在func前写入关键字prefixor、postfix修饰符来实现前缀或后缀一元运算符:

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

上面的示例为Vector2D实例实现了一元负运算符(-a)。一元负运算符是前缀运算符,因此必须使用prefix修饰符限定此方法。

对于简单的数值,一元负运算符将正数转换为负数,反之亦然。Vector2D实例的相应实现对x和y属性执行此操作:

let positive = Vector2D(x: 3.0, y: 4.0)
let negative = -positive
let alsoPositive = -negative

复合赋值运算符

复合赋值运算符将(=)与另一个运算符相结合。例如,加法赋值运算符(+=)将加法和赋值组合到单个操作中。将复合赋值运算符的左输入参数类型标记为inout,因为参数的值将直接从运算符方法中修改。

下面的示例为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

注意

无法重载默认赋值运算符(=)。只有复合赋值运算符才能重载。类似地,三元条件运算符(a ? b : c)不能重载。

等价运算符

默认情况下,自定义类和结构没有等价运算符的实现,称为等于运算符( == )和不等于 运算符( != )。通常实现运算符==,并使用标准库的运算符 != 来否定运算符 == 的结果的默认实现。有两种方法可以实现==运算符:可以自己实现它,或者对于许多类型,可以让Swift来实现。在这两种情况下,都可以遵守标准库Equatable协议。

以与实现其他中缀运算符相同的方式提供==运算符的实现:

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

上面的示例实现了一个==运算符来检查两个Vector2D实例是否具有等效值。在上下文中Vector2D,将“相等”视为“两个实例具有相同的x值和y值” ,因此这是运算符实现所使用的逻辑。

现在可以使用此运算符来检查两个Vector2D实例是否相等:

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

在许多简单的情况下,可以让Swift为提供等价运算符的综合实现。Swift为以下类型的自定义类型提供了综合实现:

要接收综合实现的==,在包含原始声明的文件中声明遵守Equatable,而不是自己实现==操作符。

下面的示例定义了三维位置矢量(x, y, z)的结构Vector3D,类似于结构Vector2D。因为x,y和z属性都是Equatable类型,所以接收综合的等价运营商的实现。

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

自定义运算符

除了Swift提供的标准运算符之外,还可以声明并实现自己的自定义运算符。有关可用于定义自定义运算符的字符列表,请参阅运算符。

新的运算符使用operator关键字全局声明,并且都标有prefix,infix或postfix修饰:

prefix operator +++

上面的示例定义了一个名为的新前缀运算符+++。此运算符在Swift中没有现有含义,因此在使用Vector2D实例的特定上下文中给出了它自己的自定义含义。出于此示例的目的,+++将其视为新的“前缀加倍”运算符。它通过使用前面定义的加法赋值运算符将向量与自身相加,使Vector2D实例的值x和y值加倍。为了实现+++运算符,添加一个名为+++的Vector2D类型方法,如下:

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

自定义中缀运算符的优先级

自定义中缀运算符均需指定优先级组。优先级组指定运算符相对于其他中缀运算符的优先级,以及运算符的关联性。有关这些特征如何影响中缀运算符与其他中缀运算符的交互的说明,请参阅优先级和关联性。

未明确放入优先级组的自定义中缀运算符将被赋予默认优先级组,其优先级即高于三元条件运算符的优先级。

以下示例定义了一个名为+-的新自定义中缀运算符,该运算符属于AdditionPrecedence优先级组:

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

该运算符将两个向量的x值相加,并从第一个向量中减去第二个向量的y值。因为它本质上是一个“加法”运算符,所以它被赋予了与加法中缀运算符相同的优先级组,例如+和-。有关Swift标准库提供的运算符的信息,包括运算符优先级组和关联性设置的完整列表,请参阅运算符声明。有关优先级组的更多信息以及定义自己的运算符和优先级组的语法,请参阅“ 运算符声明”。

注意

定义前缀或后缀运算符时,不指定优先级。但是,如果将前缀和后缀运算符同时应用于同一操作数,则首先应用后缀运算符。

上一篇 下一篇

猜你喜欢

热点阅读