17-高级运算符

//高级运算符1-5
/*
 1.溢出运算符:&+、&-、&*用来支持溢出运算
 swift的算术运算符出现溢出时会抛出运行时错误
 */
var min = UInt8.min
print(min &- 1) //255
var max = UInt8.max
print(max &+ 1) //0
print(max &* 2) //255 * 2 - 256 = 254

//2.运算符重载
struct Point {
    var x = 0, y = 0
    static func +(p1: Point, p2: Point) -> Point { //默认中缀运算符
        Point(x: p1.x + p2.x, y: p1.y + p2.y)
    }
    static func -(p1: Point, p2: Point) -> Point {
        Point(x: p1.x - p2.x, y: p1.y - p2.y)
    }
    static prefix func -(p: Point) -> Point {
        Point(x: -p.x, y: -p.y)
    }
    static func +=(p1: inout Point, p2: Point) {
        p1 = p1 + p2
    }
    static prefix func ++(p: inout Point) -> Point {
        p += Point(x: 1, y: 1)
        return p
    }
    static postfix func ++(p: inout Point) -> Point {
        let tmp = p
        p += Point(x: 1, y: 1)
        return tmp
    }
    static func == (p1: Point, p2: Point) -> Bool {
        (p1.x == p2.x) && (p1.y == p2.y)
    }
}
var p1 = Point(x: 10, y: 20)
var p2 = Point(x: -11, y: 22)
var p3 = p1 + p2
var p4 = p1 - p2
var p5 = -p1
p1 += p2
var p6 = ++p1

//3.Equatable
/*
 想要得知2个实例是否等价，一般做法是遵守Equatable协议，重载==运算符,与此同时等价于重载了!=运算符
 */
class Person : Equatable {
    var age: Int
    init(age: Int) {
        self.age = age
    }
    static func == (lhs: Person, rhs: Person) -> Bool {
        lhs.age == rhs.age
    }
}
var p7 = Person(age: 10)
var p8 = Person(age: 10)
print(p7 == p8)
//引用类型比较存储的地址值是否相等（是否引用着同一个对象）使用恒等运算符===、!==
var p11 = p7
print(p7 === p11)


/*
 swift为以下类型提供默认的Equatable实现
 */
enum Answer {
    case wrong
    case right
}
var s1 = Answer.wrong
var s2 = Answer.right
print(s1 == s2)

//只拥有遵循Equatable协议关联类型的枚举即 int String也都遵循了Equatable
enum Answer0: Equatable {
    case wrong(Int, String)
    case right
}
var s3 = Answer0.wrong(10, "Jack")
var s4 = Answer0.wrong(10, "Jack")
print(s3 == s4) //true

//只拥有遵循Equatable协议存储属性的结构体
struct Point0: Equatable {
    var x = 0, y = 0
}
var p9 = Point0(x: 10, y: 20)
var p10 = Point0(x: 10, y: 20)
print(p9 == p10)

//4.Comparable
/*
 要比较2个实例的大小，一般做法是：遵循Comparable协议，重载相应的运算符
 */
//score大的比较大，若score相等，age小的比较大
struct Student : Comparable {
    var age: Int
    var score: Int
    init(score: Int, age: Int) {
        self.score = score
        self.age = age
    }
    static func < (lhs: Student, rhs: Student) -> Bool {
        (lhs.score < rhs.score) || (lhs.score == rhs.score && lhs.age > rhs.age)
    }
    static func > (lhs: Student, rhs: Student) -> Bool {
        (lhs.score > rhs.score) || (lhs.score == rhs.score && lhs.age < rhs.age)
    }
    static func <= (lhs: Student,rhs : Student) -> Bool {
        !(lhs > rhs)
    }
    static func >= (lhs: Student,rhs : Student) -> Bool {
        !(lhs < rhs)
    }
}
var stu1 = Student(score: 100, age: 20)
var stu2 = Student(score: 98, age: 18)
var stu3 = Student(score: 100, age: 20)
print(stu1 > stu2)
print(stu1 >= stu2)
print(stu1 >= stu3)
print(stu1 <= stu3)
print(stu2 < stu1)
print(stu2 <= stu1) //全部true

//5.自定义运算符
/*
 可以自定义新的运算符：在全局作用域使用operator进行声明
 prefix operator 前缀运算符
 postfix operator 后缀运算符
 infix operator 中缀运算符：优先级组
 
 precedencegroup 优先级组 {
    associativity:结合性(left/right/none)
    higherThan:比谁的优先级高
    lowerThan:比谁的优先级低
    assignment:true 在表在可选链操作中拥有跟赋值运算符一样的优先级
 }
 */
prefix operator +++
prefix func +++ (_ i : inout Int) {
    i += 2
}
var age = 10
+++age

infix operator +- : PlusMinusPrecedence
precedencegroup PlusMinusPrecedence {
   associativity:none //
   higherThan:AdditionPrecedence
   lowerThan:MultiplicationPrecedence
   assignment:true
}
struct Point1 {
    var x = 0, y = 0
    static func +- (p1: Point1, p2: Point1) -> Point1 {
        Point1(x: p1.x + p2.x, y: p1.y - p2.y)
    }
}
var pp1 = Point1(x: 10, y: 20)
var pp2 = Point1(x: 5, y: 15)
var pp3 = pp1 +- pp2 // pp1 +- pp2 +- pp1 none下报错无结合性
print(pp3) //Point1(x: 15, y: 5)

class Person0 {
    var age = 0
    var point: Point = Point()
}
var ppp: Person0? = Person0()
//ppp?.point +- Point(x: 10, y: 20) //理解成 ppp?.point = Point(x: 10, y: 20)会怎么思考ppp为空?后的都不执行了