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)
五:自定义运算符