Swift 2 学习笔记 16.下标和运算符重载

课程来自慕课网liuyubobobo老师

下标

• 下标基础

import UIKit

struct Vector3 {
    var x: Double = 0.0
    var y: Double = 0.0
    var z: Double = 0.0
    
    subscript(index: Int) -> Double? {
        get{
            switch index {
            case 0: return x
            case 1: return y
            case 2: return z
            default: return nil
            }
        }
        set{
            guard let newValue = newValue else{ return }
            
            switch index{
            case 0: x = newValue
            case 1: y = newValue
            case 2: z = newValue
            default: return
            }
        }
    }
    
    subscript(axis: String) -> Double? {
        switch axis {
        case "x", "X": return x
        case "y", "Y": return y
        case "z", "Z": return z
        default: return nil
        }
    }
}

var v = Vector3(x: 1.0, y: 2.0, z: 3.0)
v.x  // 1
v[0]  // 1
v[6]  // nil
v["y"]  // 2
v[2] = 4.0
v[2]  // 4.0

• 多维下标

struct Matrix {
    var data: [[Double]]
    let r: Int
    let c: Int
    
    init(row: Int, col: Int) {
        self.r = row
        self.c = col
        data = [[Double]]()
        for _ in 0..<r {
            let aRow = Array(repeating: 0.0, count: col)
            data.append(aRow)
        }
    }
    
    subscript(x: Int, y: Int) -> Double{
        get{
            // 错误处理
            assert( x >= 0 && x < self.r && y >= 0 && y < self.c, "Index Out of Range" )
            return data[x][y]
        }
        set{
            assert( x >= 0 && x < self.r && y >= 0 && y < self.c, "Index Out of Range" )
            data[x][y] = newValue
        }
    }
}

var m = Matrix(row: 2, col: 2)

m[1,1]  // 0
m[1,1] = 100.0

运算符重载

• 运算符重载基础

struct Vector3 {
    var x: Double = 0.0
    var y: Double = 0.0
    var z: Double = 0.0
    
    subscript(index: Int) -> Double? {
        get{
            switch index {
            case 0: return x
            case 1: return y
            case 2: return z
            default: return nil
            }
        }
        set{
            if let value = newValue {
                switch index {
                case 0: x = value
                case 1: y = value
                case 2: z = value
                default: return
                }
            }
        }
    }
}

let v1 = Vector3(x: 1.0, y: 2.0, z: 3.0)
let v2 = Vector3(x: 3.0, y: 4.0, z: 5.0)

func + (left: Vector3, right: Vector3) -> Vector3 {
    return Vector3(x: left.x+right.x, y: left.y+right.y, z: left.z+right.z)
}

v1 + v2  // x:4 y:6 z:8

prefix func -(vector: Vector3) -> Vector3 {
    return Vector3(x: -vector.x, y: -vector.y, z: -vector.z)
}

-v1 // x:-1 y:-2 z:-3

• 重载比较运算符

struct Vector3 {
    var x: Double = 0.0
    var y: Double = 0.0
    var z: Double = 0.0
    
    subscript(index: Int) -> Double? {
        get{
            switch index {
            case 0: return x
            case 1: return y
            case 2: return z
            default: return nil
            }
        }
        set{
            if let value = newValue {
                switch index {
                case 0: x = value
                case 1: y = value
                case 2: z = value
                default: return
                }
            }
        }
    }
}

let v1 = Vector3(x: 1.0, y: 2.0, z: 3.0)
let v2 = Vector3(x: 3.0, y: 4.0, z: 5.0)

func ==(left: Vector3, right: Vector3) -> Bool {
    return left.x==right.x && left.y==right.y && left.z==right.z
}

v1 == v2  // false

• 自定义运算符

struct Vector3 {
    var x: Double = 0.0
    var y: Double = 0.0
    var z: Double = 0.0
    
    subscript(index: Int) -> Double? {
        get{
            switch index {
            case 0: return x
            case 1: return y
            case 2: return z
            default: return nil
            }
        }
        set{
            if let value = newValue {
                switch index {
                case 0: x = value
                case 1: y = value
                case 2: z = value
                default: return
                }
            }
        }
    }
}

var v1 = Vector3(x: 1.0, y: 2.0, z: 3.0)
let v2 = Vector3(x: 3.0, y: 4.0, z: 5.0)


// 后置运算符
postfix operator +++
postfix func +++(vector: inout Vector3) -> Vector3 {
    vector = Vector3(x: vector.x+1.0, y: vector.y+1.0, z: vector.z+1.0)
    return vector
}
v1+++  // x: 2.0, y: 3.0, z: 4.0

//前置运算符
infix operator ^
func ^(left: Vector3, right: Vector3) -> Double {
    return ...
}