Swift之枚举

本文首发于我的个人博客

枚举

枚举的基本用法

定义

1
2
3
4
5
6
7
//定义方向的枚举
enum Direction {
case north
case south
case east
case west
}

上面也可以写成

1
2
3
enum Direction {
case north, south, east, west
}

使用

1
2
3
4
var dir = Direction.west 
dir = Direction.east
dir = .north
print(dir) // north

也可以在switch中使用

1
2
3
4
5
6
7
8
9
10

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

关联值

有时将枚举的成员值跟其他类型的值关联存储在一起,会非常有用,可以认为将值直接存入到枚举的内存中

1
2
3
4
5

enum Score {
case points(Int)
case grade(Character)
}

如下使用:

1
2
3

var score = Score.points(88)
score = .grade("A")

如果我们想使用枚举的具体值,可以如下用 i 来保存数据

1
2
3
4
5
6
7

switch score {
case let .points(i):
print(i, "points")
case let .grade(i):
print("grade", i)
} // grade A

再比如我们想定义日期的枚举值,可以如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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):
rint(year, month, day)
case let .string(value):
print(value)
}

必要时let也可以改为var

原始值

枚举成员可以使用相同类型的默认值预先对应,这个默认值叫做:原始值

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 定义枚举
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

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

隐式原始值(Implicitly Assigned Raw Values)

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

原始值是 String 类型枚举值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// 定义枚举值
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 类型枚举值

1
2
3
4
5
6
7
8

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

如果自己指定了原始值

1
2
3
4
5
6
7
8

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

递归枚举

递归枚举要加上关键字 indirect

eg:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// 递归枚举
indirect enum ArithExpr {
case number(Int)
case sum(ArithExpr, ArithExpr)
case difference(ArithExpr, ArithExpr)
}

// 上面的递归枚举和下面的等效

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

// 下列几种使用枚举都是可以的

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


// 自己写个 calculate 方法,
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)
} }

//最终调用,计算差值
calculate(difference)

MemoryLayout

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

关联值

  • 将关联值直接存入到枚举内存中
1
2
3
4
5
6
7
8
9
// 定义枚举
enum Password {
case number(Int, Int, Int, Int)
case other
}

MemoryLayout<Password>.stride // 40, 分配占用的空间大小
MemoryLayout<Password>.size // 33, 实际用到的空间大小 4*8 + 1 = 33
MemoryLayout<Password>.alignment // 8, 对齐参数

定义变量来使用

1
2
3
4
5
6
7
8
9
10
11
12

var pwd = Password.number(9, 8, 6, 4)

MemoryLayout.stride(ofValue: pwd) // 40
MemoryLayout.size(ofValue: pwd) // 33
MemoryLayout.alignment(ofValue: pwd) // 8

// 如果改变了pwd
pwd = .other
MemoryLayout.stride(ofValue: pwd) // 40
MemoryLayout.size(ofValue: pwd) // 33
MemoryLayout.alignment(ofValue: pwd) // 8

原始值

  • 原始值不会直接存入到枚举内存中
  • 如果是下面这种枚举,只需要1个字节就可以了
  • 一个字节可以存放 FF 也就是 0~255个枚举值。如果
1
2
3
4
5
6
7
enum Season : Int {
case spring, summer, autumn = 8, winter
}

MemoryLayout<Season>.stride // 1, 分配占用的空间大小
MemoryLayout<Season>.size // 1, 实际用到的空间大小 1
MemoryLayout<Season>.alignment // 1, 对齐参数

窥探内存

使用 窥探内存细节的小工具 我们可以很轻松的获取swift中,这些枚举值的内存地址

简单枚举内存

1
2
3
4
5
6
7
8
9

enum TestEnum{
case k0,k1,k2,k3
}

var t = TestEnum.k1
print(Mems.ptr(ofVal: &t))

t = TestEnum.k2

执行完 print(Mems.ptr(ofVal: &t)) 代码之后
输出

1
0x00000001000054b8

此时去查看 0x00000001000054b8地址的数据,

1
01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

执行完 t = TestEnum.k2 之后

此时去查看 0x00000001000054b8地址的数据,

1
02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

具体查看内存

假设我们有这么下面带代码,考虑下内存怎么布局呢?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

enum TestEnum {
case test1(Int, Int, Int)
case test2(Int, Int)
case test3(Int)
case test4(Bool)
case test5
}

print(MemoryLayout<TestEnum>.size) // 25, 分配占用的空间大小
print(MemoryLayout<TestEnum>.stride) //32, 实际用到的空间大小
print(MemoryLayout<TestEnum>.alignment)// 8, 对齐参数


var e = TestEnum.test1(1, 2, 3)
print(Mems.ptr(ofVal: &e))


e = .test2(4, 5)
print(Mems.memStr(ofVal: &e))

e = .test3(6)

e = .test4(true)

e = .test5

执行完之后,可知

TestEnum 这个占用内存为:

  • print(MemoryLayout.size) // 25, 分配占用的空间大小
  • print(MemoryLayout.stride) //32, 实际用到的空间大小
  • print(MemoryLayout.alignment)// 8, 对齐参数

具体内存里面存的是什么呢?可以借助上面说的 窥探内存细节的小工具 打印出来内存,然后利用Xcode的 view Memory 查看具体内存的值

结果如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
enum TestEnum {
case test1(Int, Int, Int)
case test2(Int, Int)
case test3(Int)
case test4(Bool)
case test5
}


print(MemoryLayout<TestEnum>.size) // 25, 分配占用的空间大小
print(MemoryLayout<TestEnum>.stride) //32, 实际用到的空间大小
print(MemoryLayout<TestEnum>.alignment)// 8, 对齐参数

// 1个字节存储成员值
// N个字节存储关联值(N取占用内存最大的关联值),任何一个case的关联值都共用这N个字节
// 共用体

// 小端:高高低低
// 01 00 00 00 00 00 00 00 //对应的TestEnum.test1传入的数值
// 02 00 00 00 00 00 00 00
// 03 00 00 00 00 00 00 00
// 00 // TestEnum.test1在第0个位置
// 00 00 00 00 00 00 00
var e = TestEnum.test1(1, 2, 3)
print(Mems.ptr(ofVal: &e))

// 04 00 00 00 00 00 00 00
// 05 00 00 00 00 00 00 00
// 00 00 00 00 00 00 00 00
// 01 // TestEnum.test1在第1个位置
// 00 00 00 00 00 00 00
e = .test2(4, 5)
print(Mems.memStr(ofVal: &e))

// 06 00 00 00 00 00 00 00
// 00 00 00 00 00 00 00 00
// 00 00 00 00 00 00 00 00
// 02
// 00 00 00 00 00 00 00
e = .test3(6)

// 01 00 00 00 00 00 00 00
// 00 00 00 00 00 00 00 00
// 00 00 00 00 00 00 00 00
// 03
// 00 00 00 00 00 00 00
e = .test4(true)

// 00 00 00 00 00 00 00 00
// 00 00 00 00 00 00 00 00
// 00 00 00 00 00 00 00 00
// 04
// 00 00 00 00 00 00 00
e = .test5

只有一个case

假如只有一个case,其占用的空间为0,不需要存值来区分是哪个case

1
2
3
4
5
6
7
enum TestEnum {
case spring
}

print(MemoryLayout<TestEnum>.size) // 0, 分配占用的空间大小
print(MemoryLayout<TestEnum>.stride) //1, 实际用到的空间大小
print(MemoryLayout<TestEnum>.alignment)// 1, 对齐参数

只有一个case,有关联值

1
2
3
4
5
6
7
enum TestEnum {
case spring(Int)
}

print(MemoryLayout<TestEnum>.size) // 8, 分配占用的空间大小
print(MemoryLayout<TestEnum>.stride) //8, 实际用到的空间大小
print(MemoryLayout<TestEnum>.alignment)// 8, 对齐参数

参考资料:

Swift官方源码

从入门到精通Swift编程

窥探内存细节的小工具

------ 本文结束感谢您的阅读 ------