iOS --- 下标和计算符重载（swift2.3）

iOS — 下标和计算符重载（swift）

下面简单的介绍下标和计算符重载的应用

1. 下标基础

2. 多维下标

3. 运算符重载基础

4. 重载比较运算符

5. 自定义运算符

---

一：下标基础

struct Vector3 {

    var x:Double = 0.0

    var y:Double = 0.0

    var z:Double = 0.0


    subscript(index: Int) ->Double?{//int表示下标的类型是int类型，double表示返回值是double类型,但是可能出现下标越界，那么返回值就应该是double？

        get{

            switch index{

            case 1: return x

            case 2: return y

            case 3: return z

            default: return nil

            }

        }

        set{//由于传递进来的值可以不是double类型，那么就要解包

            /*
             这里可以用if let  else解包，也可以使用guard else 解包
             guard let newValue = newValue else{

            return

            }
            */
            if let newValue = newValue{//由于返回值是double？类型，所以拿到的newValue要先解包

                switch  index{

                case 1: self.x = newValue

                case 2: self.y = newValue

                case 3: self.z = newValue

                default: return

                }




            }else{

            return//没有return任何值表明什么也不做，就是外部的赋值没有效果

            }



                }

    }

}

    var  v = Vector3(x: 3, y: 3, z: 4)


v[0]

v[2] = 55

v[2]

二：多维下标

//使用二维的下标

三：运算符重载基础

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?{

        get{
            switch axis{
            case "x","X": return x
            case "y","Y": return y
            case "z","Z": return z
            default: return nil
            }
        }

        set{
            guard let newValue = newValue else{ return }

            switch axis{
            case "x","X": x = newValue
            case "y","Y": y = newValue
            case "z","Z": z = newValue
            default: return
            }
        }
    }

    func length() -> Double{
        return sqrt( x*x + y*y + z*z )
    }
}

//这里需要注意的是：运算符的重载必须将重载函数写在类的外面，因为函数必须知道Vector3是个什么东西
func + (left: Vector3, right: Vector3) -> Vector3{//这里就是将“+”这个运算符简单的看做为一个函数，
    return Vector3(x: left.x + right.x, y: left.y + right.y, z: left.z + right.z)
}

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

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

func * (left: Vector3, a: Double) -> Vector3{
    return Vector3(x: left.x * a, y: left.y * a, z: left.z * a)
}

func += (inout left: Vector3, right: Vector3){
    left = left + right
}

四：重载比较运算符

//通过以及定义好的重载运算符再次再次进行重载，也就是复用


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?{

        get{
            switch axis{
            case "x","X": return x
            case "y","Y": return y
            case "z","Z": return z
            default: return nil
            }
        }

        set{
            guard let newValue = newValue else{ return }

            switch axis{
            case "x","X": x = newValue
            case "y","Y": y = newValue
            case "z","Z": z = newValue
            default: return
            }
        }
    }
}


let va = Vector3(x: 1.0, y: 2.0, z: 3.0)
let vb = Vector3(x: 3.0, y: 4.0, z: 5.0)


// 重载比较运算符

// 自定义类型初始不能作比较
// va == vb

// 对于struct，===也不能使用
//va === vb

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

va == vb

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

va != vb


func <(left: Vector3, right: Vector3) -> Bool{
    if left.x != right.x{ return left.x < right.x }
    if left.y != right.y{ return left.y < right.y }
    if left.z != right.z{ return left.z < right.z }
    return false
}

func <=(left: Vector3, right: Vector3) -> Bool{
    return left < right || left == right
}

func >(left: Vector3, right: Vector3) -> Bool{
    return !(left <= right)
}

func >=(left: Vector3, right: Vector3) -> Bool{
    return !(left < right)
}


var c = Vector3(x: 1, y: 2, z: 3)

var b = Vector3(x: 1, y: 2, z: 3)

五：自定义运算符