Swift 运算符操作

在Swift中延伸了一种和C++类似的新特性，Swift的运算符提供了良好的可拓展性，我们可以对运算符进行操作，对运算符的操作其实就是对运算函数的重写或者重载。注意运算符操作一般被操做的参数往往要加上In-Out模式。

+、-(运算符重载)

我们在实际开发中，Swift可自定义运算符，并不限于预设的运算符，我们可以对+进行重载，使其完成Int与Double或者Flaot相加。
Swift提供了如下的函数，使得Int与Int可以相加：

       func + (left:Int,right:Int)->Int{
       return left+right

}
我们完全可以进行重构

func + (left:Int,right:Double)->Double
{
 return Double(left)+right

}

实现+运算符对数组进行添加元素

      func +<T>(var left:[T],right:T)->[T]
  {
       left.append(right)
       return left
  } 

经过实验，貌似Swift不支持对 = 的重构

++、–（前、后置运算符)

前面我们说的+以及没有说的-是双目运算符，而对于单目运算符，如++，–，Swift规定操作数放在单目运算符前面，这种运算符被称为前置运算符，操作数放在单目运算符后面，这种运算符被称为后置运算符。

重置前置运算符函数必须使用prefix关键字修饰，重置后置运算符必须使用postfix关键字修饰。

    prefix  func  ++ (operator:Type)->Type
{

 let result=++operator

}

                 `前置运算符函数`

postfix  func  -- (operator:Type)->Type
{

         let result=operator--
}

                 `后置运算符函数` 

---

例子：

      prefix func ++ <T> (inout array:[T])->[T] {
         array.append(array[array.count-1])
         return array
    }

    var strArr=["iOS","Android","WP"]
    print(++strArr)

+=(赋值运算符)

在C语言中提供了+=赋值运算符，实际就是把第二个值相加给第一个值，这里的第一个值就需要使用In-Out模式。

 func += <T>(inout left:[T],right:T)
{
left.append(right)
}

var myList=["iOS","Android"];
myList += "WP"
print(myList)

比较运算符

Swift中的Int、Double、String等类型都支持比较运算符，但如果自己定义的类型需要比较大小，则需要为自定义类型满足如下两个特征：

• 遵守Equatable、Comparable两个协议。

• 对自定义类型重载==和<两个运算符。
  只需要对自定义类型重载了==和<两个运算符，Swift即可以自动推断出!=、<=、>、>=这四种结果。

  格式如下：

    func  <(las:Type,hrs:Type)->Bool
    {
         let result=lhs<rhs
    }
  

  例子

   struct WXrect:Equatable,Comparable
   {
       var left:Double
       var top:Double
   var width:Double
       var height:double
      }
  fun ==(las:WXrect,hrs:WXrect)->Bool
  {
   return lhs.width*lhs.height==rhs.width*rhs.height
      }
  fun < (las:WXrect,hrs:WXrect)->Bool
  {
  return ls.width`*`ls.height`<`rhs.width*rhs.height
  }
      let rect1=WXrect(left:2.0,top:3.0,width:5.0,height:4.0)
      let rect2=WXrect(left:8.0,top:23.0,width:2.0,height:8.0)
                        letrect3=WXrect(left:7.0,top:3.0,width:10.0,height:10.0)
  
  print(rect1<rect2)
  print(rect1<=rect2)
  print(rect1!=rect2)
  print(rect1>rect2)
  

进阶—开发自己的运算符

经过上边的积累，我们已经掌握了运算符的操作，最后我们进行自己的运算符开发

两步搞定一个自定义运算符

1. 声明 新的运算符。

   格式如下：

   prefix|infix|postfix operator 运算符名{} 
   
   prefix：代表前置运算符
   infix：代表双目运算符
   postfix：代表后置运算符
   

2. 为新的运算符提供多个重载的运算符函数

如果重载的运算符是前置运算符，则需要在func关键字添加prefix关键字
如果重载的运算符是后置运算符，则需要在func关键字添加postfix关键字

下面抛砖引玉的开发一个乘方运算符：**

由于乘法应该是双目运算符，所以首先声明新的运算符：**

infix operator **{}

为新的运算符提供重载函数

     func ** (base:Int,exponent:Int)->Int
{
   var result = 1
  for _ in 1...exponent
{
 result *= base
}
return result
}

let a=5
let b=3
print("\(a)的\(b)次方为:\(a ** b)")

怎样？Swift强大吧！自己自定义运算符

下面我们看一道数学题

              20+10-5*5*5*2-30

这道题怎么做？我有些不会了！O(∩_∩)O哈哈~

这道数学题侧面反映了运算符是有先后执行顺序的，那么我们自定义第运算符不应该也有运算规则呢！

结合性(associativity)的值可取的值有left，right和none。左结合运算符跟其他优先级相同的左结合运算符写在一起时，会跟左边的操作数结合。同理，右结合运算符会跟右边的操作数结合。而非结合运算符不能跟其他相同优先级的运算符写在一起。默认优先性为100

infix operator **= { associativity left precedence 140 }
fun ** (base:Int,exponent:Int)
 {

}