swift2.0 学习笔记Twenty-two

import UIKit

class ViewController: UIViewController {

    

    override func viewDidLoad() {

        super.viewDidLoad()

        //位运算符(~)

        //位运算符可以操作一个数据结构中每个独立的位。它们通常被用在底层开发中。

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

        let initialBits : UInt8 = 0b00001111

        let invertedBits = ~initialBits //等于 0b11110000

        print(initialBits)//15

        print(invertedBits)//240

        

        //按位与运算符(&)

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

        let firstSixBits:UInt8 = 0b11111100

        let lastSixBits:UInt8 = 0b00111111

        let middleFourBits = firstSixBits & lastSixBits//等于00111100

        print(middleFourBits)//60

        

        //按位或运算符(|)

        //可以对两个数的比特位进行比较。它返回一个新数。只要两个操作符的对应位中有任意一个为1时，该数的对应位就为1.

        let someBits:UInt8 = 0b00010011

        let moreBits:UInt8 = 0b00001110

        let combineBits = someBits | moreBits //等于00011111

        print(combineBits)//31

        

        //按位异或运算符(^)

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

        let firstBits : UInt8 = 0b00010100

        let otherBits : UInt8 = 0b00000101

        let outPutBits = firstBits ^ otherBits //00010001

        

        

        //按位左移/右移运算符（<<）/(>>)

        //按位左移运算符<< 和按位右移运算符>> 可以对一个数进行指定位数的左移和右移。

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

        let shiftBits :UInt8 = 4 //0b00000100

        shiftBits << 1 //00001000

       

        //溢出运算符

        //当向一个整数赋超过它容量的值时，swift默认会报错，而不是生成一个无效的数。

        //比如：Int16整数能容纳的有符号整数范围是 -32768到32768。

        var Overflow = Int16.max

//        Overflow += 1 //这里会报错

        //为过大或过小的数值提供错误处理，能让我们在处理边界值时更加灵活

        //可以使用swift提供的三个溢出操作符来让系统支持整数溢出运算

        // 溢出加法&+  溢出减法&-  溢出乘法&*

        

        var unsignedOverflow = UInt8.max

        unsignedOverflow = unsignedOverflow &+ 1

        print(unsignedOverflow)//0

        //数值溢出后，留在UInt8边界的值是00000000，也就是0

        

        //运算符函数

        //类和结构可以为现有的操作符提供自定义的实现，这通常被称为运算符重载

        let vector = Vector2D(x: 3.0, y: 1.0)

        let anotherVector = Vector2D(x: 2.0, y: 4.0)

        let combinedVector = vector + anotherVector

        print(combinedVector)//Vector2D(x: 5.0, y: 5.0)

        

        //要实现前缀或者后缀运算符，需要在声明运算符函数的时候在func关键字之前指定prefix或者postfix限定符。

        let hh = Vector2D(x: 4.0, y: 5.0)

        let neg = -hh

        print(neg)//Vector2D(x: -4.0, y: -5.0)

        let alsoneg = -neg

        print(alsoneg)//Vector2D(x: 4.0, y: 5.0)

        

        //复合赋值运算符

        //复合赋值运算符将赋值运算符＝与其它运算符进行结合。在实现的时候，需要把运算符的左参数设置成inout类型，因为这个参数的值会在运算符函数内直接被修改

        var original = Vector2D(x: 1.0, y: 2.0)

        let vectorToAdd = Vector2D(x: 3.0, y: 4.0)

        original += vectorToAdd

        print(original)//Vector2D(x: 4.0, y: 6.0)

      

        //前缀自增运算符

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

        print(++toIncrement)//Vector2D(x: 3.0, y: 4.0)

        

        //等价操作符

        //自定义的类和结构体没有对等价操作符进行默认实现，对于自定义类型，swift无法判断是否“相等”，因为相等的含义取决于这些自定义类型在你的代码中所扮演的角色。

        let twoThree = Vector2D(x: 2.0, y: 3.0)

        let another = Vector2D(x: 2.0, y: 3.0)

        if twoThree == another{

            print("相等！")

        }else{

            print("不相等！")

        }//相等！

        

        //自定义运算符

        //新的运算符要在全局作用域内，使用operator关键字进行声明，同时还要指定prefix、infix或者postfix限定符：

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

        +++toBeDoubled

        print(toBeDoubled)//Vector2D(x: 2.0, y: 8.0)

        

    }

}

prefix operator +++ {}

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

    vector += vector

    return vector

}

func != (left:Vector2D,right:Vector2D)->Bool{

    return !(left==right)

}

func == (left:Vector2D,right:Vector2D)->Bool{

    return (left.x==right.x) && (left.y==right.y)

}

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

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

    return vector

}

func += (inout left:Vector2D,right:Vector2D){

    left = left + right

}

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

    

    return Vector2D(x: -vector.x, y: -vector.y)

}

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)

}

//看到这里相信大家对swift有一定的了解。不过有些知识点个人觉得不是很重要，所以有所取舍。

//希望本人的整理对大家的学习有所帮助，到这里就不在更新了，谢谢大家的支持。