知识点15:枚举

• 枚举的基本用法。

//Swift的枚举成员在被创建时不会被赋予一个默认的整型值。
enum Direction {
    case north
    case south
    case east
    case west
}

//多个成员值可以出现在同一行上，用逗号隔开。
enum Color {
   case red,green,blue
}

var dir = Direction.north
dir = .north

var color = Color.green
color = .red

//使用Switch语句匹配枚举值
switch dir {
case .north:
    print("north")
case .south:
    print("south")
case .east:
    print("east")
case .west:
    print("west")
}

• 关联值 。

// 有时候会将枚举的成员值跟其他类型的关联存储在一起，会非常有用。
enum Score {
    case ponts(Int)
    case grade(Character)
}

var scoreValue = Score.ponts(98)
scoreValue = .grade("A")

switch scoreValue {
case let .ponts(i):
    print(i,"ponts")
case let .grade(i):
    print(i,"grade")
}

enum date {
    
    case digit(year:Int,moth:Int,day:Int)
    case describe(String)
}

var dateValue = date.digit(year: 2021, moth: 3, day: 12)
dateValue = .describe("2021-3-12")

switch dateValue {
case .digit(let year, let moth,let day):
    print("year\(year),moth\(moth),day\(day)")
case .describe(let des):
    print(des)
}

• 原始值。

//枚举成员可以使用相同类型的默认值预先关联，这个默认值叫做：原始值。原始值可以是字符串，字符，或者任意整型值或浮点型值。

enum ManType:String{
    case man = "🧑"
    case woman = "👱‍♀️"
}

var per = ManType.man
print(per)
print(per.rawValue)

• 隐式原始值。

//如果枚举的原始值类型是Int,String会自动分配原始值。
enum Season:String {
    case spring = "spring"
    case summer = "summer"
    case autumn = "autumn"
    case winter = "winter"
}

var sea = Season.spring
print(sea.rawValue)//spring
//当使用字符串作为枚举类型的原始值时，每个枚举成员的隐式原始值为该枚举成员的名称。
enum SeasonType:String {
    case spring, summer,autumn,winter
}

var seaType = SeasonType.spring
print(seaType.rawValue)//spring


enum BookIndex:Int{
    case top,left,bottom,right
}
//使用枚举成员的rawValue属性可以访问该枚举成员的原始值。
print(BookIndex.top.rawValue)//0

enum roomIndex:Int{
    case up = 1,left,down = 4,right
}

print(roomIndex.left.rawValue)//2
print(roomIndex.right.rawValue)//5

• 递归枚举。

//方式一：indirect 修饰全部
indirect enum ArithExpr {
    case number(Int)
    case sum(ArithExpr,ArithExpr)
    case different(ArithExpr,ArithExpr)
}

//方式二：indirect 修饰单个

enum ArithExprEnum {
  case number(Int)
  indirect case sum(ArithExprEnum,ArithExprEnum)
  indirect case different(ArithExprEnum,ArithExprEnum)
}

let five = ArithExprEnum.number(5)
let four = ArithExprEnum.number(4)
let arithExprSumValue = ArithExprEnum.sum(five, four)
let arithExprDifferentValue = ArithExprEnum.different(five, four)

func calculateValue (_ expr:ArithExprEnum) ->Int{
    switch expr {
    case let .number(value):
        return value
    case let .sum(v1, v2):
        return calculateValue(v1) + calculateValue(v2)
    case let .different(v1, v2):
        return calculateValue(v1) - calculateValue(v2)
    }
}

calculateValue(five)//5
calculateValue(arithExprSumValue)//9
calculateValue(arithExprDifferentValue)//1

• MemoryLayout。

//MemoryLayout 获取数据类型占用的内存大小
MemoryLayout<Int>.size//实际空间的大小
MemoryLayout<Int>.stride//分配占用的空间大小
MemoryLayout<Int>.alignment//对齐参数
let memoryValue = 4
MemoryLayout.size(ofValue: memoryValue)//8

enum Password {
    
    case number(Int,Int,Int,Int)
    case other
    
}

var pwd = Password.number(1, 2, 1, 1)
pwd = .other
MemoryLayout.size(ofValue: pwd)//33