1. 溢出运算符
- Swift 的算数运算符出现溢出时,会抛出运行时错误
- Swift 有溢出运算符(&+、&-、&*),用来支持溢出运算
注意:
使用溢出运算符计算时,当出现溢出时,为保证在该范围内,会在该范围内循环
print(Int8.min)//-128
print(Int8.max)//127
print(uint8.min)//0
print(uint8.max)//255
var v : Int8 = Int8.max
//v = v+1 // 运行时报错
v = v &+ 1
print(v) //-128
var v2 : Int8 = Int8.min
v2 = v2 &- 1
print(v2)//127
var v3 : uint8 = uint8.max
v3 = v3 &* 2
print(v3)//254
2. 运算符重载
类、结构体、枚举可以为现有的运算符提供自定义的实现,这个操作就叫做:运算符重载
//运算符重载
struct Point:CustomStringConvertible {
var x: Int8 = 0, y: Int8 = 0
static func + (p1:Point, p2:Point) -> Point{
return Point(x: p1.x+p2.x, y: p1.y+p2.y)
}
static func - (p1:Point, p2:Point) -> Point{
return Point(x: p1.x-p2.x, y: p1.y-p2.y)
}
static prefix func - (p1:Point) -> Point{
return Point(x: -p1.x, y: -p1.y)
}
static func += ( p1: inout Point, p2:Point){
p1 = p1 + p2
}
static prefix func ++ (p: inout Point) -> Point{
p = p + Point(x: 1, y: 1)
return p
}
static postfix func ++ (p: inout Point) -> Point{
let temp = p
p += Point(x: 1, y: 1)
return temp
}
var description: String{
return "Point.x = \(x) Point.y = \(y)"
}
}
var p1 = Point(x: 10, y: 10)
var p2 = Point(x: 20, y: 20)
print(p1 + p2)//Point.x = 30 Point.y = 30
print(p1 - p2)//Point.x = -10 Point.y = -10
print(-p1)//Point.x = -10 Point.y = -10
p1 += p2
print(p1)//Point.x = 30 Point.y = 30
var p3 = Point(x: 10, y: 10)
var p4 = Point(x: 20, y: 20)
var p5 = p3 + ++p2
print("p5:",p5)//p5: Point.x = 31 Point.y = 31
p5 = p3 + p4++
print("p5:",p5)//p5: Point.x = 30 Point.y = 30
3. Equatable协议(比较两个实例是否等价)
- 要想得知2个实例是否等价,一般做法是遵守
Equatable
协议,重载==
运算符 - 引用类型比较存储的地址是否相等(是否引用着同一个对象),使用恒等运算符
===
、!==
class Person: Equatable {
var age: Int
init(age: Int) {
self.age = age
}
public static func == (lhs: Person, rhs: Person) -> Bool {
return lhs.age == rhs.age
}
}
var p1 = Person(age: 10)
var p2 = Person(age: 10)
print(p1 == p2)//true
print(p1 != p2)//false
注意
:
如果Person类不继承Equatable协议
,只能使用==
运算符,!=
运算符不可用;
如果Person类继承了Equatable协议
,如果重载了 ==
运算符,也就等价于重载了 !=
运算符
- Swift为一下类型提供默认的Equatable实现:
- 没有关联类型的枚举类型
- 只拥有遵守Equatable协议关联类型的枚举
- 只拥有遵守Equatable协议存储属性的结构体
enum Answer: Equatable {
case wrong(Int)
case right
}
var s1 = Answer.wrong(10)
var s2 = Answer.wrong(10)
print(s1 == s2)
4. Comparable (比较大小)
要想比较2个实例大小,一般做法是:遵守Comparable协议
、重载相应的运算符
// 规则:score大的比较大,若score相等,age小的比较大
struct Student:Comparable {
var score: Int
var age: Int
init(score: Int, age: Int) {
self.score = score
self.age = age
}
static func < (lhs: Self, rhs: Self) -> Bool{
(lhs.score < rhs.score) || (lhs.score == rhs.score && lhs.age > rhs.age)
}
static func <= (lhs: Self, rhs: Self) -> Bool{
(lhs.score < rhs.score) || (lhs.score == rhs.score && lhs.age == rhs.age)
}
static func >= (lhs: Self, rhs: Self) -> Bool{
(lhs.score > rhs.score) || (lhs.score == rhs.score && lhs.age == rhs.age)
}
static func >(lhs: Self, rhs: Self) -> Bool{
(lhs.score > rhs.score) || (lhs.score == rhs.score && lhs.age < rhs.age)
}
}
var s1 = Student(score: 88, age: 18)
var s2 = Student(score: 88, age: 20)
var s3 = Student(score: 90, age: 18)
var s4 = Student(score: 70, age: 10)
print(s1 > s2) //true
print(s2 > s3) //false
print(s3 >= s4) //true
print(s4 <= s4) //true
5. 自定义运算符(Operator)了解
- 可以自定义新的运算符:在全局作用域使用
operator
进行声明
prefix operator
前缀运算符
postfix operator
后缀运算符
infix operator
中缀运算符:优先级组
prefix operator +++
prefix func +++ (_ i: inout Int){
i += 2
}
var age = 10
+++age
print(age)//12
6. Extension(扩展)
- Swift中的扩展,类似于OC中的分类(Category)
- 扩展可以为枚举、结构体、类、协议添加新功能
可以添加方法、计算属性、下标、(便捷)初始化器、嵌套类型、协议等等
- 扩展不能办到:
- 不能覆盖原有功能
- 不能添加存储属性,不能向已有的属性添加属性观察器
- 不能添加父类
- 不能添加指定初始化器,不能添加反初始化器
- ......
注意
:指定、便捷初始化器是类里面的概念
如果希望自定义初始化器的同时,编译器也能够生成默认初始化器,则可以在扩展中编写初始化器。
required初始化器也不能写在扩展中
extension Array {
subscript(nullable idx: Int) ->Element?{
if(startIndex..<endIndex).contains(idx){
return self[idx]
}
return nil
}
}
var arr:Array<Int> = [11,22,33,44]
print(arr[nullable: -1] as Any)//nil
print(arr[nullable: 1] as Any)//22
给一个类扩展协议
class Person {
var age = 0
init(age: Int) {
self.age = age
}
}
extension Person: Equatable{
static func == (lhs: Person, rhs: Person) -> Bool{
if lhs.age == rhs.age {
return true
}
return false
}
}
var p1 = Person(age: 10)
var p2 = Person(age: 10)
print(p1 == p2)//true
扩展协议:
扩展可以给协议提供默认实现,也可以间接实现【可选协议】的效果
扩展可以给协议扩充【协议从未声明过的方法】
//是否是奇数
extension BinaryInteger{
func isOdd() -> Bool {
self % 2 != 0
}
}
print(10.isOdd())//false
print(3.isOdd())//true