C语言枚举
enum 枚举名 {
枚举值1,
枚举值2,
……};
一周七天可以写成
enum week
{
MON, TUE, WED, THU, FRI, SAT, SUN
};
第⼀个枚举成员的默认值为整型的 0，后⾯的枚举值依次类推，如果我们想更改，只需要这样操作
enum week
{
MON = 1, TUE, WED, THU, FRI, SAT, SUN
};
那如何定义⼀个枚举变量
enum week
{
MON = 1, TUE, WED, THU, FRI, SAT, SUN
} week;
//可以省略声明的枚举
enum week
{
MON = 1, TUE, WED, THU, FRI, SAT, SUN
} week;
Swift 枚举写法
enum week{
case MONDAY
case TUEDAY
case WEDDAY
case THUDAY
case FRIDAY
case SATDAY
case SUNDAY
}
上述代码也可以直接⼀个 case ,然后⽤逗号隔开
enum week{
case MONDAY, TUEDAY, WEDDAY, THUDAY, FRIDAY, SATDAY, SUNDAY
}
枚举值默认是整形,也以表达为String
enum week: String
{
case MON = "MON"
case TUE = "TUE"
case WED = "WED"
case THU = "THU"
case FRI = "FRI"
case SAT = "SAT"
case SUN = "SUN"
}
我们赋值的字符串叫做原始值(RawValue),,如果我们不想写后⾯的字符串，这个时候我们就 可以使⽤ 隐⼠ RawValue 分配
enum week: Int { case mon, tue, wed, thu, fri = 10, sat, sun }
print(week.fri.rawValue)
···········
10
enum week: String { case MON, TUE, WED, THU, FRI , SAT, SUN }
print(week.FRI.rawValue)
···········
FRI
当改成String型之后，打印的值就变成了当前枚举值了。
通过swiftc -emit-sil main.swift | xcrun swift-demangle > ./main.sil && open main.sil查看sil代码
enum week : String {
case MON, TUE, WED, THU, FRI, SAT, SUN
typealias RawValue = String
init?(rawValue: String)
var rawValue: String { get }
}
// main
sil @main : $@convention(c) (Int32, UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>) -> Int32 {
bb0(%0 : $Int32, %1 : $UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>):
alloc_global @main.w : Swift.String // id: %2
%3 = global_addr @main.w : Swift.String : $*String // user: %8
%4 = metatype $@thin week.Type
%5 = enum $week, #week.MON!enumelt // user: %7
// function_ref week.rawValue.getter
%6 = function_ref @main.week.rawValue.getter : Swift.String : $@convention(method) (week) -> @owned String // user: %7
%7 = apply %6(%5) : $@convention(method) (week) -> @owned String // user: %8
store %7 to %3 : $*String // id: %8
%9 = integer_literal $Builtin.Int32, 0 // user: %10
%10 = struct $Int32 (%9 : $Builtin.Int32) // user: %11
return %10 : $Int32 // id: %11
} // end sil function 'main'
%6调用了get方法，7%将%5也就是枚举值MON传参进去
// week.rawValue.getter
sil hidden @main.week.rawValue.getter : Swift.String : $@convention(method) (week) -> @owned String {
// %0 // users: %2, %1
bb0(%0 : $week):
//声明一个变量self，等于参数week
debug_value %0 : $week, let, name "self", argno 1 // id: %1
//匹配枚举值，跳转到对应的分支
switch_enum %0 : $week, case #week.MON!enumelt: bb1, case #week.TUE!enumelt: bb2, case #week.WED!enumelt: bb3, case #week.THU!enumelt: bb4, case #week.FRI!enumelt: bb5, case #week.SAT!enumelt: bb6, case #week.SUN!enumelt: bb7 // id: %2
//创建String，跳转bb8
bb1: // Preds: bb0
%3 = string_literal utf8 "MON" // user: %8
%4 = integer_literal $Builtin.Word, 3 // user: %8
%5 = integer_literal $Builtin.Int1, -1 // user: %8
%6 = metatype $@thin String.Type // user: %8
// function_ref String.init(_builtinStringLiteral:utf8CodeUnitCount:isASCII:)
%7 = function_ref @Swift.String.init(_builtinStringLiteral: Builtin.RawPointer, utf8CodeUnitCount: Builtin.Word, isASCII: Builtin.Int1) -> Swift.String : $@convention(method) (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> @owned String // user: %8
%8 = apply %7(%3, %4, %5, %6) : $@convention(method) (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> @owned String // user: %9
br bb8(%8 : $String) // id: %9
...
//返回
// %52 // user: %53
bb8(%52 : $String): // Preds: bb7 bb6 bb5 bb4 bb3 bb2 bb1
return %52 : $String // id: %53
} // end sil function 'main.week.rawValue.getter : Swift.String'
case 和 rawValue
print(week.MON)
print(week.MON.rawValue)
虽然打印的都是MON，但是一个是枚举类型，一个是字符串类型
枚举的init
通过sil文件查看init方法
// week.init(rawValue:)
sil hidden @main.week.init(rawValue: Swift.String) -> main.week? : $@convention(method) (@owned String, @thin week.Type) -> Optional<week> {
// %0 // users: %164, %158, %79, %3
bb0(%0 : $String, %1 : $@thin week.Type):
%2 = alloc_stack $week, var, name "self" // users: %162, %154, %143, %132, %121, %110, %99, %88, %165, %159
debug_value %0 : $String, let, name "rawValue", argno 1 // id: %3
%4 = integer_literal $Builtin.Word, 7 // user: %6
// function_ref _allocateUninitializedArray<A>(_:)
%5 = function_ref @Swift._allocateUninitializedArray<A>(Builtin.Word) -> ([A], Builtin.RawPointer) : $@convention(thin) <τ_0_0> (Builtin.Word) -> (@owned Array<τ_0_0>, Builtin.RawPointer) // user: %6
%6 = apply %5<StaticString>(%4) : $@convention(thin) <τ_0_0> (Builtin.Word) -> (@owned Array<τ_0_0>, Builtin.RawPointer) // users: %8, %7
//构建元组，存放字符串数组和指针地址
%7 = tuple_extract %6 : $(Array<StaticString>, Builtin.RawPointer), 0 // users: %80, %79
%8 = tuple_extract %6 : $(Array<StaticString>, Builtin.RawPointer), 1 // user: %9
%9 = pointer_to_address %8 : $Builtin.RawPointer to [strict] $*StaticString // users: %17, %69, %59, %49, %39, %29, %19
%10 = string_literal utf8 "MON" // user: %12
%11 = integer_literal $Builtin.Word, 3 // user: %16
%12 = builtin "ptrtoint_Word"(%10 : $Builtin.RawPointer) : $Builtin.Word // user: %16
br bb1 // id: %13
bb1: // Preds: bb0
%14 = integer_literal $Builtin.Int8, 2 // user: %16
br bb2 // id: %15
bb2: // Preds: bb1
%16 = struct $StaticString (%12 : $Builtin.Word, %11 : $Builtin.Word, %14 : $Builtin.Int8) // user: %17
store %16 to %9 : $*StaticString // id: %17
%18 = integer_literal $Builtin.Word, 1 // user: %19
%19 = index_addr %9 : $*StaticString, %18 : $Builtin.Word // user: %27
%20 = string_literal utf8 "TUE" // user: %22
%21 = integer_literal $Builtin.Word, 3 // user: %26
%22 = builtin "ptrtoint_Word"(%20 : $Builtin.RawPointer) : $Builtin.Word // user: %26
br bb3 // id: %23
//通过方法来进行匹配
bb14: // Preds: bb13
%76 = struct $StaticString (%72 : $Builtin.Word, %71 : $Builtin.Word, %74 : $Builtin.Int8) // user: %77
store %76 to %69 : $*StaticString // id: %77
// function_ref _findStringSwitchCase(cases:string:)
%78 = function_ref @Swift._findStringSwitchCase(cases: [Swift.StaticString], string: Swift.String) -> Swift.Int : $@convention(thin) (@guaranteed Array<StaticString>, @guaranteed String) -> Int // user: %79
%79 = apply %78(%7, %0) : $@convention(thin) (@guaranteed Array<StaticString>, @guaranteed String) -> Int // users: %149, %138, %127, %116, %105, %94, %83, %147, %136, %125, %114, %103, %92, %81
release_value %7 : $Array<StaticString> // id: %80
debug_value %79 : $Int, let, name "$match" // id: %81
%82 = integer_literal $Builtin.Int64, 0 // user: %84
%83 = struct_extract %79 : $Int, #Int._value // user: %84
%84 = builtin "cmp_eq_Int64"(%82 : $Builtin.Int64, %83 : $Builtin.Int64) : $Builtin.Int1 // user: %85
cond_br %84, bb15, bb16
//如果成功，返回
bb15: // Preds: bb14
%86 = metatype $@thin week.Type
%87 = enum $week, #week.MON!enumelt // user: %89
%88 = begin_access [modify] [static] %2 : $*week // users: %89, %90
store %87 to %88 : $*week // id: %89
end_access %88 : $*week // id: %90
br bb29 // id: %91
//不成功继续匹配
bb16: // Preds: bb14
debug_value %79 : $Int, let, name "$match" // id: %92
%93 = integer_literal $Builtin.Int64, 1 // user: %95
%94 = struct_extract %79 : $Int, #Int._value // user: %95
%95 = builtin "cmp_eq_Int64"(%93 : $Builtin.Int64, %94 : $Builtin.Int64) : $Builtin.Int1 // user: %96
cond_br %95, bb17, bb18 // id: %96
bb29: // Preds: bb27 bb25 bb23 bb21 bb19 bb17 bb15
%162 = load %2 : $*week // user: %163
//返回的是可选类型，如果没有就是nil
%163 = enum $Optional<week>, #Optional.some!enumelt.1, %162 : $week // user: %166
release_value %0 : $String // id: %164
dealloc_stack %2 : $*week // id: %165
br bb30(%163 : $Optional<week>)
// %167 // user: %168
bb30(%167 : $Optional<week>): // Preds: bb29 bb28
return %167 : $Optional<week> // id: %168
} // end sil function 'main.week.init(rawValue: Swift.String) -> main.week?'
枚举的遍历
enum week: String { case MON, TUE, WED, THU, FRI , SAT, SUN }
extension week: CaseIterable{}
var allCase = week.allCases
for c in allCase {
print(c)
}
只要实现了CaseIterable协议就可以。
关联值
如果我们想⽤枚举表达更复杂的信息，⽽不仅仅是⼀个 RawValue 这么简单，这个时候我们就可以使⽤ Associated Value,当声明了关联值后，就无法使用init和RawValue
enum Shape{
case circle(radious: Double)
case rectangle(width: Int, height: Int)
}
var circle = Shape.circle(radious: 10.0)
circle = Shape.circle(radious: 20.0)
switch circle{
case let .circle(radious):
print(radious)
case .rectangle(let width, var height):
height += 10
print(width,height)
}
//也可以单独取出来用
if case let Shape.circle(radious) = circle{
print(radious)
}
当我们只关注不同枚举值的相同关联值
enum Shape{
case rectangle(width: Int, height: Int)
case squar(width1: Int, height1: Int)
}
var circle = Shape.rectangle(width: 30, height: 40)
switch circle{
case let .rectangle(10, x), let .squar(width1: 10, height1: x):
print(x)
default:
print("nil")
}
注意，前后变量要一一对应。不关注的也以用_来省略
枚举的嵌套
枚举中含有枚举
enum CombineDirect{
enum BaseDirect{
case up
case down
case left
case right
}
case leftUp(combineElement1: BaseDirect, combineElement2: BaseDirect)
case rightUp(combineElement1: BaseDirect, combineElement2: BaseDirect)
case leftDown(combineElement1: BaseDirect, combineElement2: BaseDirect)
case rightDown(combineElement1: BaseDirect, combineElement2: BaseDirect)
}
let combind = CombineDirect.leftDown(combineElement1: .left, combineElement2: .down)
结构体中包含枚举
struct Skill{
enum KeyType{
case up
case down
case left
case right
}
let key: KeyType
func launchSkill(){
switch key {
case .left,.right:
print("left, right")
case .down,.up:
print("up, down")
}
}
}
枚举中包含属性
enum 中能包含计算属性，类型属性。不能包含存储属性
enum Shape{
case circle(radious: Double)
case rectangle(width: Int, height: Int)
// var radious: Double
static var height = 20.0
var width: Double{
get{
return 10.0
}
}
}
枚举中包含方法
enum week: Int {
case MON, TUE, WED, THU, FRI , SAT, SUN
mutating func nextDay(){
if self == .SUN{
self = week(rawValue: 0)!
}else{
self = week(rawValue: self.rawValue + 1)!
}
}
}
枚举的大小
枚举的大小取决于枚举值，默认是UInt8大小，也就是一字节，超过UInt8容量就会升级为UInt16，也就是二字节，以此类推。
存在关联值，取决最大case的大小
enum Shape{
case circle(radious: Double)
case rectangle(width: Int)
}
print(MemoryLayout<Shape>.stride)
print(MemoryLayout<Shape>.size)
·····
16
9
Double占8字节，加上case的1字节，就是9字节，根据字节对齐，所以步长是16。
indirect
enum List<T>{
case end
indirect case node(T, next: List<T>)
}
print(MemoryLayout<List<String>>.size)
print(MemoryLayout<List<String>>.stride)
·············
8
8
打印添加了indirect的枚举大小为8字节
var node = List<Int>.node(10, next: List<Int>.end)
·················
(lldb) p withUnsafePointer(to: &node, {$0})
(UnsafePointer<swiftTest.List<Int>>) $R6 = 0x0000000100003068
(lldb) x/4g 0x0000000100003068
0x100003068: 0x0000000100419fd0 0x00007fff98c81218
0x100003078: 0x00007fff98c81218 0x00000001007824d0
(lldb) x/4g 0x0000000100419fd0
0x100419fd0: 0x0000000100002030 0x0000000000000002
0x100419fe0: 0x000000000000000a 0x0000000000000000
通过打印地址，发现把声明了indirect关键字的值放在了堆空间上。
查看sil
// main
sil @main : $@convention(c) (Int32, UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>) -> Int32 {
bb0(%0 : $Int32, %1 : $UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>):
alloc_global @main.node : main.List<Swift.Int> // id: %2
%3 = global_addr @main.node : main.List<Swift.Int> : $*List<Int> // user: %16
%4 = metatype $@thin List<Int>.Type
%5 = integer_literal $Builtin.Int64, 10 // user: %6
%6 = struct $Int (%5 : $Builtin.Int64) // user: %13
%7 = metatype $@thin List<Int>.Type
%8 = enum $List<Int>, #List.end!enumelt // user: %14
%9 = alloc_box $<τ_0_0> { var (τ_0_0, next: List<τ_0_0>) } <Int> // users: %15, %10
%10 = project_box %9 : $<τ_0_0> { var (τ_0_0, next: List<τ_0_0>) } <Int>, 0 // users: %12, %11
%11 = tuple_element_addr %10 : $*(Int, next: List<Int>), 0 // user: %13
%12 = tuple_element_addr %10 : $*(Int, next: List<Int>), 1 // user: %14
store %6 to %11 : $*Int // id: %13
store %8 to %12 : $*List<Int> // id: %14
%15 = enum $List<Int>, #List.node!enumelt.1, %9 : $<τ_0_0> { var (τ_0_0, next: List<τ_0_0>) } <Int> // user: %16
store %15 to %3 : $*List<Int> // id: %16
%17 = integer_literal $Builtin.Int32, 0 // user: %18
%18 = struct $Int32 (%17 : $Builtin.Int32) // user: %19
return %18 : $Int32 // id: %19
} // end sil function 'main'
通过官方文档可以查看alloc_box的解释
Allocates a reference-counted @box on the heap large enough to hold a value of type T, along with a retain count and any other metadata required by the runtime. The result of the instruction is the reference-counted @box reference that owns the box. The project_box instruction is used to retrieve the address of the value inside the box.
在堆上分配一个引用计数的@box，其大小足以容纳类型T的值，以及retain计数和运行时所需的任何其他元数据。该指令的结果是引用计数的@box引用，该引用拥有该框。project_box指令用于检索框内值的地址。
OC-Swift混编
我们在Swift的枚举前加上@objc就可以了
@objc enum WEEK: Int {
case MON, TUE
}
编译一下，我们就可以在.h文件中查看
查看转译文件.png
typedef SWIFT_ENUM(NSInteger, WEEK, closed) {
WEEKMON = 0,
WEEKTUE = 1,
};
OC仅能使用声明为Int类型的。
NS_ENUM
**********OC**********
NS_ENUM(NSInteger, OCENUM){
Value1,
Value2
};
**********SWIFT**********
public var OCENUM: OCENUM
public enum OCENUM : Int {
case Value1 = 0
case Value2 = 1
}
typedef enum
如果用typedef enum来声明，就会编译成结构体
**********OC**********
typedef enum {
Num1,
Num2
} OCNum;
**********SWIFT**********
public struct OCNum : Equatable, RawRepresentable {
public init(_ rawValue: UInt32)
public init(rawValue: UInt32)
public var rawValue: UInt32
}
typedef NS_ENUM
**********OC**********
typedef NS_ENUM(NSInteger, CEnum) {
CEnumInvalid = 0,
CEnumA = 1,
CEnumB,
CEnumC
};
**********SWIFT**********
public enum CEnum : Int {
case invalid = 0
case A = 1
case B = 2
case C = 3
}
网友评论