05-枚举

//枚举1-8
//1.枚举的基本用法
enum Direction0 {
    case north
    case south
    case west
    case east
}

//等价于
enum Direction1 {
    case east, west, south, north
}

var dir = Direction0.west
dir = Direction0.east
dir = .south
print(dir)

switch dir {
case .east:
    print("east")
case .west:
    print("west")
case .south:
    print("south")
case .north:
    print("north")
}

//2.关联值 有时将枚举的成员值跟其他类型的值关联在一起，会非常有用
enum Score {
    case points(Int)
    case grade(Character)
}
var score = Score.points(96)
score = .grade("A")

switch score {
case let .points(i):
    print(i, "points")
case let .grade(i): //必要时let 也可改为var
    print("grade",i)
}

enum Date {
    case digit(year: Int, month: Int, day: Int)
    case string(String)
}
var date = Date.digit(year: 2011, month: 9, day: 10)
date = .string("2011-09-10")
switch date {
    case .digit(let year, let month, let day):
    print(year, month, day)
case let .string(value): //注意let的位置不同意义也不同
    print(value)
}

//3.关联值举例
enum Passord {
    case numebr(Int, Int, Int, Int)
    case gesture(String)
}
var pwd = Passord.numebr(3, 5, 7, 8)
pwd = .gesture("12369")

switch pwd {
case let .numebr(n1, n2, n3, n4):
    print("number is",n1, n2, n3, n4)
case let .gesture(str):
    print("gesture is",str)
}

//4.原始值 枚举成员可以使用相同类型的默认值预先对应，这个默认值叫做原始值,原始值不占用枚举变量的内存
enum PokerSuit : Character {
    case spade = "♠"
    case heart = "♥"
    case diamond = "♦"
    case club = "♣"
}
var suit = PokerSuit.spade
print(suit)//spade
print(suit.rawValue)//♠
print(PokerSuit.club.rawValue)//♣

enum Grade : String {
    case perfect = "A"
    case great = "B"
    case good = "C"
    case bad = "D"
}
print(Grade.perfect.rawValue)
print(Grade.great.rawValue)
print(Grade.good.rawValue)
print(Grade.bad.rawValue)

//5.隐式原始值,如果枚举的原始值类型是Int、String,Swift会自动分配原始值
enum Direction2 : String {
    case east = "east"
    case west = "west"
    case south = "wouth"
    case north = "north"
}
//等价于
enum Direction3 : String {
    case east, west, south, north
}

enum Season0 : Int {
    case spring, summer, autumn, winter
}
print(Season0.spring.rawValue)//0
print(Season0.summer.rawValue)//1
print(Season0.autumn.rawValue)//2
print(Season0.winter.rawValue)//3

enum Season1 : Int {
    case spring = 1, summer, autumn = 4, winter
}
print(Season1.spring.rawValue)//1
print(Season1.summer.rawValue)//2
print(Season1.autumn.rawValue)//4
print(Season1.winter.rawValue)//5

//6.递归枚举 indirect
indirect enum ArithExpr0 {
    case number(Int)
    case sum(ArithExpr0, ArithExpr0)
    case difference(ArithExpr0, ArithExpr0)
}

enum ArithExpr1 {
    case number(Int)
    indirect case sum(ArithExpr1, ArithExpr1)
    indirect case difference(ArithExpr1, ArithExpr1)
}

let two = ArithExpr0.number(2)
let four = ArithExpr0.number(4)
let five = ArithExpr0.number(5)
let sum = ArithExpr0.sum(four, five)
let difference = ArithExpr0.difference(sum, two)

func calculate(_ expr: ArithExpr0) -> Int {
    switch expr {
    case let .number(value):
        return value
    case let .sum(left, right):
        return calculate(left) + calculate(right)
    case let .difference(left, right):
        return calculate(left) - calculate(right)
    }
}
calculate(difference)//7

//7.MemoryLayout 获取数据类型占用的内存大小
enum Passsord {
    case number(Int, Int, Int, Int)
    case other
}
MemoryLayout<Passsord>.stride    //40,分配占用的空间大小
MemoryLayout<Passsord>.size      //33,实际用到的空间大小
MemoryLayout<Passsord>.alignment //8,对齐参数

var pwd0 = Passsord.number(9, 8, 6, 4)
pwd0 = .other
MemoryLayout.stride(ofValue: pwd0)
MemoryLayout.size(ofValue: pwd0)
MemoryLayout.alignment(ofValue: pwd0)

//关联值和原始值的区别？关联值是存储在变量里的，原始值是存储在枚举里

/* 8.汇编
 r开头:64bit,8字节
 e开头:32bit,4字节
 ax,bx,cx:16bit,2字节
 ah,al:8bit,1字节
 
 rip 存储的是指令的地址，CPU要存储的下一条指令地址就存储在rip中
 */