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

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

一：下标基础

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)

五：自定义运算符