swift的枚举

    // 枚举的基本用法
    enum Direction {
        case north
        case south
        case east
        case west
    }
    
    enum DirectionOther {
        case north,south,east,west
    }
    
    fileprivate func directionTest(){
        var dir = Direction.west
        dir = .north
        switch dir {
        case .north:
            print("north")
        case .south:
            print("south")
        case .east:
            print("east")
        case .west:
            print("west")
        }
    }
    
    
    // 关联值(Associated Values)有时会将枚举的成员值跟其他类型的关联存储在一起,会非常有用
    enum Score {
        case points(Int)          // 成绩表达有两种:一种是数字,一种是字符
        case grade(Character)
    }
    
    
    enum Date {
        case digit(year:Int,month:Int,day:Int)
        case string(String)
    }
    
    
 
    
    fileprivate func scoreTest(){
        var score = Score.points(96)
        score  = .grade("A")
        switch score {
        case let .points(i):
            print("point",i)
        case let .grade(i):
            print("grade",i)
            
        }
    }
    
    fileprivate func dateTest(){
        var date = Date.digit(year: 2011, month: 9, day: 10)
        date = .string("2011-09-10")
        
        switch date {
        case let .digit(year: ye, month: mon, day: da):
            print(ye,mon,da)
        case let .string(value):
            print(value)
        }
    }
    
    
    // 原始值(Raw Values)枚举成员可以使用相同类型的默认值g预先关联,这个默认值叫做:原始值
    enum Grade:String {
        case perfect = "A"
        case great = "B"
        case good = "C"
        case bad = "D"
    }
   
    
    fileprivate func gradeTest(){
        print(Grade.perfect.rawValue)
        print(Grade.great.rawValue)
        print(Grade.good.rawValue)
        print(Grade.bad.rawValue)
    }
    
    
    // 隐式原始值(Implicitly Assigned Raw Values)
    // 如果枚举的原始值类型是Int,String,Swift会自动分配原始值
    
    
    // 递归枚举(Recursive Enumeration)
    // 算术表达式
    indirect enum ArithExpr {
        case number(Int)
        case sum(ArithExpr,ArithExpr)
        case difference(ArithExpr,ArithExpr)
    }
    
    fileprivate func arithExprTest() {
        let five = ArithExpr.number(5)
        let four = ArithExpr.number(4)
        let two = ArithExpr.number(2)
        let sum = ArithExpr.sum(five, four)
        let diff = ArithExpr.difference(sum, two)
        calculate(diff)
    }
    
    fileprivate func calculate(_ expr:ArithExpr) -> 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)
        }
    }
    
    
    
    // MemoryLayout 可以使用MemoryLayout获取数据类型占用的内存大小
    fileprivate func memoryLayoutTest(){
        MemoryLayout<Int>.size
        MemoryLayout<Int>.stride
        MemoryLayout<Int>.alignment
    }
    
    enum Password {
        case number(Int,Int,Int,Int)
        case other
    }
    
    fileprivate func passwordTest(){
        var pwd = Password.number(5, 6, 4, 7) // 32个字节
        pwd = .other    // 32个字节
        
        MemoryLayout<Password>.size         // 33, 实际用到的空间大小
        MemoryLayout<Password>.stride       // 40,分配占用的空间大小
        MemoryLayout<Password>.alignment    // 8,对齐参数
    }
    
    enum Season:Int {
        case spring = 1, summer = 2, autumn = 3, winter = 4
    }
    
    
    fileprivate func seasonTest(){
        MemoryLayout<Season>.size         // 1, 实际用到的空间大小
        MemoryLayout<Season>.stride       // 1,分配占用的空间大小
        MemoryLayout<Season>.alignment    // 8,对齐参数
    }
    
    /*
     关联值与原始值的区别:
        Password是关联值,是以后可以传入不同的值var pwd1 = Password.number(5, 6, 4, 7),var pwd2 = Password.number(111, 23, 34, 75),意味着每一个枚举变量都要有自己的内存来存储传进来的变量,传进来的关联值直接存储在枚举的内存中,所以如果枚举变量是关联值的话,是跟传入值的大小有关;
     而Season原始值是永远跟成员绑定在一起,spring就是1,summer就是2,autumn就是3,所以原始值是固定死的,不会把枚举变量存储在枚举的内存中.
     
     */