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有一定的了解。不过有些知识点个人觉得不是很重要，所以有所取舍。

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