Swift - 枚举

1. 枚举的基本用法

enum Direction {
    case north
    case south
    case east
    case west
}

另一种等价写法

enum Direction {
    case north, south, east, west
}

使用枚举

var dir = Direction.west
dir = Direction.east
dir = .north //已经确定类型后，就可以使用这种简写方式
print(dir) // north

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

2. 关联值（Associated Values）

有时将枚举的成员值跟其他类型的值关联存储在一起，会非常有用

可以理解为：将各种类型的数据直接存储到枚举变量里面去

场景： 分数（points表示实际得分，grade表示分数的等级）

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):
    print("grade", i)
}

场景：日期（digit表示使用年月日形式，string表示使用字符串形式）

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):
    print(value)
}

必要时let也可以改为var

分别设置每一个参数

case .digit(let year, var month, let day):
    print(year, month, day)

表示全部使用let

case let .digit(year, month, day):
    print(year, month, day)

表示全部使用var

case var .digit(year, month, day):
    print(year, month, day)

3. 关联值举例

常用密码形式有数字密码、手势密码

定义枚举：number代表是数字密码；gesture代表手势密码

enum Password {
    case number(Int, Int, Int, Int, Int, Int)
    case gesture(String)
}

var pwd = Password.number(3, 5, 7, 8, 0, 9)
pwd = .gesture("14789")

switch pwd {
case let .number(n1, n2, n3, n4, n5, n6):
    print("number is ", n1, n2, n3, n4, n5, n6)
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)  // suit
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)  // A
print(Grade.great.rawValue)  // B
print(Grade.good.rawValue)  // C
print(Grade.bad.rawValue)  // D

注意：原始值不占用枚举变量的内存

5. 隐式原始值（Implicitly Assigned Raw Values）

如果枚举的原始值类型是Int、String，Swift会自动分配原始值

String

enum Direction : String {
    case north = "north"
    case south = "south"
    case east = "east"
    case west = "west"
}

等价于

enum Direction : String {
    case north, south, east, west
}

打印：

print(Direction.north)  // north
print(Direction.north.rawValue)  // north

Int

默认Int原始值从0开始顺序递增

// 季节
enum Season : Int {
    case spring, summer, autumn, winter
}
print(Season.spring.rawValue)  // 1
print(Season.summer.rawValue)  // 2
print(Season.autumn.rawValue)  // 3
print(Season.winter.rawValue)  // 4

自定义Int原始值

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

6. 递归枚举（Recursive Enumeration）

枚举类型里面，case用到枚举类型是自己本身，就叫做递归枚举。

递归枚举必须使用indirect关键字

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

也可以有用到递归枚举的case才写indirect

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

7. MemoryLayout

可以使用MemoryLayout获取数据类型占用的内存大小

使用方法

var age = 10
MemoryLayout<Int>.size // 获取实际使用多少内存
MemoryLayout<Int>.stride // 获取系统分配了多少内存
MemoryLayout<Int>.alignment // 获取内存对其的大小

MemoryLayout.size(ofValue: age)
MemoryLayout.stride(ofValue: age)
MemoryLayout.alignment(ofValue: age)

关联值类型

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

var pwd = Password.number(5, 6, 4, 7)
pwd = .other

MemoryLayout<Password>.size  // 33
MemoryLayout<Password>.stride  // 40
MemoryLayout<Password>.alignment  // 8

分析：

• .size为33，是number(32字节)+other(1字节)。number是关联值类型，实际会把值存储到变量里去，所以这边需要32字节。但是如果把other一起存储在这32字节，就无法区分判断number、other，所以other单独分配了一个字节
• .stride为40，是因为内存对其，实际使用了33字节，对其后就是40

原始值类型

enum Season : Int {
    case spring, summer, autumn, winter
}

var s = Season.spring  // 0
var s1 = Season.spring  // 0
var s2 = Season.spring  // 0

MemoryLayout<Season>.size  // 1
MemoryLayout<Season>.stride  // 1
MemoryLayout<Season>.alignment  // 1

分析：

• 原始值占用的是1字节
• 因为原始值一开始就固定了，使用1字节就能够表示。

如下，String的原始值的枚举又是怎样的？

enum Season : String {
    case spring = "aaa", summer, autumn, winter
}

实际上它也都是1

这时候枚举仍然使用0 1 2 3来表示每一个case就行，要获取原始值则使用.rawValue去读取

@oubijiexi