swift学习笔记之-高级运算符

//高级运算符

 

import UIKit

 

/*高级运算符(Advanced Operators):位运算符、溢出运算符、优先级和结合性、运算符函数、自定义运算符

 

位运算符:

    1.位运算符可以操作数据结构中每个独立的比特位。它们通常被用在底层开发中,比如图形编程和创建设备驱动。位运算符在处理外部资源的原始数据时也十分有用,比如对自定义通信协议传输的数据进行编码和解码

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

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

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

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

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

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

        1.对无符号整数进行移位的规则如下:

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

            2.任何因移动而超出整型存储范围的位都会被丢弃。

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

        2.有符号整数的移位运算相对复杂得多,这种复杂性源于有符号整数的二进制表现形式:

            1.有符号整数使用第 1 个比特位(通常被称为符号位)来表示这个数的正负。符号位为 0 代表正数,为 1 代表负数,其余的比特位(通常被称为数值位)存储了实际的值。有符号正整数和无符号数的存储方式是一样的,都是从 0 开始算起

            2.负数的存储方式略有不同。它存储的值的绝对值等于 2 的 n 次方减去它的实际值(也就是数值位表示的值),这里的 n 为数值位的比特位数。一个 8 比特位的数有 7 个比特位是数值位,所以是 2 的 7 次方,即 128

            3.如:1 1111100,符号位为 1,说明这是一个负数,另外 7 个位则代表了数值 124(即 128 - 4)的二进制表示,结果是-(128-124) = -4

 

            4.如果想对两个Int8进行加法运算,我们只需要将这两个数的全部 8 个比特位进行相加,并且将计算结果中超出 8 位的数值丢弃

            5.当对正整数进行按位右移运算时,遵循与无符号整数相同的规则,但是对于移位产生的空白位使用符号位进行填充,而不是用 0

 

溢出运算符:在默认情况下,当向一个整数赋予超过它容量的值时,Swift 默认会报错,而不是生成一个无效的数

    1.也可以选择让系统在数值溢出的时候采取截断处理,而非报错。可以使用 Swift 提供的三个溢出运算符来让系统支持整数溢出运算。这些运算符都是以 & 开头的:

        溢出加法 &+

        溢出减法 &-

        溢出乘法 &*

    2.数值溢出:数值有可能出现上溢或者下溢,在对有符号整型数值进行溢出加法或溢出减法运算时,符号位也需要参与计算

        var unsignedOverflow = UInt8.max    // unsignedOverflow 等于 UInt8 所能容纳的最大整数 255

        unsignedOverflow = unsignedOverflow &+ 1    // 此时 unsignedOverflow 等于 0

 

优先级和结合性:运算符的优先级使得一些运算符优先于其他运算符,高优先级的运算符会先被计算,结合性定义了相同优先级的运算符是如何结合的(左结合、右结合)

 

运算符函数:

    1.类和结构体可以为现有的运算符提供自定义的实现,这通常被称为运算符重载

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

单目前缀和后缀运算符、双目中缀运算符:

    1.单目运算符只运算一个值,当运算符出现在值之前时,它就是前缀的(例如 -a),而当它出现在值之后时,它就是后缀的(例如 i++)。

    2.要实现前缀或者后缀运算符,需要在声明运算符函数的时候在 func 关键字之前指定 prefix 或者 postfix 修饰符

复合赋值运算符:将赋值运算符(=)与其它运算符进行结合。例如,将加法与赋值结合成加法赋值运算符(+=)。在实现的时候,需要把运算符的左参数设置成 inout 类型,因为这个参数的值会在运算符函数内直接被修改

等价运算符:自定义的类和结构体没有对等价运算符进行默认实现,等价运算符通常被称为“相等”运算符(==)与“不等”运算符(!=),自定义实现的方法与其它中缀运算符一样

 

自定义运算符:

    1.除了实现标准运算符,在 Swift 中还可以声明和实现自定义运算符

    2.新的运算符要使用 operator 关键字在全局作用域内进行定义,同时还要指定 prefix、infix 或者 postfix 修饰符:

        如:prefix operator +++ {}

自定义中缀运算符的优先级和结合性:自定义的中缀运算符也可以指定优先级和结合性

    1.结合性可取的值有left,right 和 none,非结合none运算符不能跟其他相同优先级的运算符写在一起

    2.结合性的默认值是 none,优先级的默认值 100

    3.

*/

let initialBits: UInt8 = 0b00001111

let invertedBits = ~initialBits // 等于 0b11110000

 

let firstSixBits: UInt8 = 0b11111100

let lastSixBits: UInt8  = 0b00111111

let middleFourBits = firstSixBits & lastSixBits // 等于 00111100

 

let someBits: UInt8 = 0b10110010

let moreBits: UInt8 = 0b01011110

let combinedbits = someBits | moreBits // 等于 11111110

 

let firstBits: UInt8 = 0b00010100

let otherBits: UInt8 = 0b00000101

let outputBits = firstBits ^ otherBits // 等于 00010001

 

let shiftBits: UInt8 = 4 // 即二进制的 00000100

shiftBits << 1           // 00001000

shiftBits << 2           // 00010000

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

 

var unsignedOverflow = UInt8.min            // unsignedOverflow 等于 UInt8 所能容纳的最小整数 0

unsignedOverflow = unsignedOverflow &- 1    // 此时 unsignedOverflow 等于 255

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

signedOverflow = signedOverflow &- 1        // 此时 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)

}

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

 

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

}

 

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)

 

//=================

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)

 

转载于:https://www.cnblogs.com/susufufu/p/5705631.html

你可能感兴趣的:(swift学习笔记之-高级运算符)