帅驼驼
帅驼驼

Swift底层进阶--010：枚举

C语⾔枚举

先来回顾⼀下C语⾔的枚举写法：

enum 枚举名 {
    枚举值1,
    枚举值2,
    ......
};

⽐如表示⼀周 7天，⽤C语⾔的枚举写法应该是这样的：

enum week {
    MON, TUE, WED, THU, FRI, SAT, SUN
};

第⼀个枚举成员默认值为0，后⾯枚举值依次类推。如果更改只需这样操作：

enum week {
    MON = 1, TUE, WED, THU, FRI, SAT, SUN
};

定义⼀个枚举变量week：

enum Week {
    MON = 1, TUE, WED, THU, FRI, SAT, SUN
} week;

同样是定义⼀个枚举变量week，省略枚举名称：

enum {
    MON = 1, TUE, WED, THU, FRI, SAT, SUN
} week;
Swift中的枚举
枚举基础

⽐如表示⼀周 7天，⽤Swift的枚举写法应该是这样的：

enum Week {
    case MONDAY
    case TUEDAY
    case WEDDAY
    case THUDAY
    case FRIDAY
    case SATDAY
    case SUNDAY
}

上述代码也可以直接⼀个case，然后⽤逗号隔开：

enum Week {
    case MON, TUE, WED, THU, FRI, SAT, SUN
}

Swift中可以创建String类型枚举。在Swift中=左边的值叫枚举值，右边的叫rawValue原始值，case 枚举值 = rawValue原始值

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属性，编译报错

Swift底层进阶--010：枚举_第1张图片
未指定类型的枚举

Int类型枚举，枚举值FRI分配rawValue为10，MON依然是从0开始，后⾯枚举值依次类推。在FRI之后的枚举值从11开始，依次类推

enum Week: Int {
    case MON, TUE, WED, THU, FRI = 10, SAT, SUN
}

print("MON：\(Week.MON.rawValue),SAT：\(Week.SAT.rawValue)")

//输出以下内容：
//MON：0,SAT：11

String类型枚举，枚举值FRI分配rawValue打印Hello，其他未分配rawValue打印自身枚举值

enum Week: String {
    case MON, TUE, WED, THU, FRI = "Hello", SAT, SUN
}

print("MON：\(Week.MON.rawValue),FRI：\(Week.FRI.rawValue),SUN：\(Week.SUN.rawValue)")

//输出以下内容：
//MON：MON,FRI：Hello,SUN：SUN

通过SIL代码，分析String类型枚举，是如何打印rawValue的

enum Week: String {
    case MON, TUE, WED, THU, FRI, SAT, SUN
}

let w: Week = .MON

将上述代码生成SIL文件：swiftc -emit-sil main.swift | xcrun swift-demangle

enum Week : String {
  case MON, TUE, WED, THU, FRI, SAT, SUN
  typealias RawValue = String
  init?(rawValue: String)
  var rawValue: String { get }
}

SIL代码的枚举声明除了case还多了一些东西：

  • 首先通过typealias取别名，在枚举Week里把String取名为RawValue
  • 生成可选的初始化方法init?(rawValue: String)，也就是说初始化可以返回nil
  • 生成rawValue计算属性，所以在代码中访问rawValue属性，本质就是访问它的get方法
// main
sil @main : $@convention(c) (Int32, UnsafeMutablePointer>>) -> Int32 {
bb0(%0 : $Int32, %1 : $UnsafeMutablePointer>>):
  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'

main方法：

  • %5接收枚举值
  • %6获取Week.rawValue.getter方法地址
  • 通过apply调用getter方法%6，传入参数枚举值%5，将返回值赋值给%7
  • 将返回结果%7存储到%3 
// Week.rawValue.getter
sil hidden @main.Week.rawValue.getter : Swift.String : $@convention(method) (Week) -> @owned String {
// %0 "self"                                      // users: %2, %1
bb0(%0 : $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

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

bb2:                                              // Preds: bb0
  %10 = string_literal utf8 "TUE"                 // user: %15
  %11 = integer_literal $Builtin.Word, 3          // user: %15
  %12 = integer_literal $Builtin.Int1, -1         // user: %15
  %13 = metatype $@thin String.Type               // user: %15
  // function_ref String.init(_builtinStringLiteral:utf8CodeUnitCount:isASCII:)
  %14 = 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: %15
  %15 = apply %14(%10, %11, %12, %13) : $@convention(method) (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> @owned String // user: %16
  br bb8(%15 : $String)                           // id: %16

bb3:                                              // Preds: bb0
  %17 = string_literal utf8 "WED"                 // user: %22
  %18 = integer_literal $Builtin.Word, 3          // user: %22
  %19 = integer_literal $Builtin.Int1, -1         // user: %22
  %20 = metatype $@thin String.Type               // user: %22
  // function_ref String.init(_builtinStringLiteral:utf8CodeUnitCount:isASCII:)
  %21 = 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: %22
  %22 = apply %21(%17, %18, %19, %20) : $@convention(method) (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> @owned String // user: %23
  br bb8(%22 : $String)                           // id: %23

bb4:                                              // Preds: bb0
  %24 = string_literal utf8 "THU"                 // user: %29
  %25 = integer_literal $Builtin.Word, 3          // user: %29
  %26 = integer_literal $Builtin.Int1, -1         // user: %29
  %27 = metatype $@thin String.Type               // user: %29
  // function_ref String.init(_builtinStringLiteral:utf8CodeUnitCount:isASCII:)
  %28 = 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: %29
  %29 = apply %28(%24, %25, %26, %27) : $@convention(method) (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> @owned String // user: %30
  br bb8(%29 : $String)                           // id: %30

bb5:                                              // Preds: bb0
  %31 = string_literal utf8 "FRI"                 // user: %36
  %32 = integer_literal $Builtin.Word, 3          // user: %36
  %33 = integer_literal $Builtin.Int1, -1         // user: %36
  %34 = metatype $@thin String.Type               // user: %36
  // function_ref String.init(_builtinStringLiteral:utf8CodeUnitCount:isASCII:)
  %35 = 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: %36
  %36 = apply %35(%31, %32, %33, %34) : $@convention(method) (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> @owned String // user: %37
  br bb8(%36 : $String)                           // id: %37

bb6:                                              // Preds: bb0
  %38 = string_literal utf8 "SAT"                 // user: %43
  %39 = integer_literal $Builtin.Word, 3          // user: %43
  %40 = integer_literal $Builtin.Int1, -1         // user: %43
  %41 = metatype $@thin String.Type               // user: %43
  // function_ref String.init(_builtinStringLiteral:utf8CodeUnitCount:isASCII:)
  %42 = 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: %43
  %43 = apply %42(%38, %39, %40, %41) : $@convention(method) (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> @owned String // user: %44
  br bb8(%43 : $String)                           // id: %44

bb7:                                              // Preds: bb0
  %45 = string_literal utf8 "SUN"                 // user: %50
  %46 = integer_literal $Builtin.Word, 3          // user: %50
  %47 = integer_literal $Builtin.Int1, -1         // user: %50
  %48 = metatype $@thin String.Type               // user: %50
  // function_ref String.init(_builtinStringLiteral:utf8CodeUnitCount:isASCII:)
  %49 = 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: %50
  %50 = apply %49(%45, %46, %47, %48) : $@convention(method) (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> @owned String // user: %51
  br bb8(%50 : $String)                           // id: %51

// %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'

Week.rawValue.getter方法：

  • bb0，接收一个枚举值，self就是该枚举值，通过switch_enum匹配跳转到对应bb1至bb7代码分支
  • bb1至bb7，构建出对应枚举值的字符串，最终都调用bb8
  • bb8返回对应字符串

rawValue.getter返回的字符串在编译时期已经存储好，通过Mach-O文件查看它们的存储位置

Swift底层进阶--010：枚举_第2张图片
Mach-O

rawValue的字符串存储在 __TEXT.__cstring段，而且内存地址是连续的。在上述SIL代码中构建枚举值字符串，本质就是从 Mach-O里把对应地址的字符串取出来

区分case和rawValue
enum Week: String {
    case MON, TUE, WED, THU, FRI, SAT, SUN
}

print("case枚举值：\(Week.MON)")
print("rawValue原始值：\(Week.MON.rawValue)")

//输出以下内容：
//case枚举值：MON
//rawValue原始值：MON

上述代码中，case枚举值Week.MON和rawValue原始值Week.MON.rawValue打印出的内容完全一致，但一个是输出枚举值，一个是访问rawValue的get方法，它们是完全不同的东西

Swift底层进阶--010：枚举_第3张图片
编译报错
做一个简单的测试，如果将 String类型的 Week.MON.rawValue赋值给 Week类型 week1，再将 Week类型 Week.MON赋值给 String类型 week2，都会编译报错

init方法的调用时机

添加符号断点Week.init，预期断住枚举初始化方法

Swift底层进阶--010：枚举_第4张图片
Symbol 

enum Week: String {
    case MON, TUE, WED, THU, FRI, SAT, SUN
}

let week: Week = Week.MON

print("case枚举值：\(week)")
print("rawValue原始值：\(week.rawValue)")

//输出以下内容：
//case枚举值：MON
//rawValue原始值：MON

运行上述代码，没有达到预期，没有任何断点被触发

enum Week: String {
    case MON, TUE, WED, THU, FRI, SAT, SUN
}

print(Week(rawValue: "MON"))
print(Week.init(rawValue: "TUE"))
print(Week(rawValue: "Hello"))

//输出以下内容：
//Optional(LGSwiftTest.Week.MON)
//Optional(LGSwiftTest.Week.TUE)
//nil

修改上述代码，使用Week(rawValue:)或Week.init(rawValue:)成功触发断点

Swift底层进阶--010：枚举_第5张图片
Week.init

继续执行代码，从运行结果来看，前两个打印Optional可选值，第三个打印nil，因为找不到对应Hello的枚举值

Swift底层进阶--010：枚举_第6张图片
运行结果

通过SIL代码，分析枚举的初始化构造函数

enum Week: String {
    case MON, TUE, WED, THU, FRI, SAT, SUN
}

print(Week(rawValue: "Hello"))

将上述代码生成SIL文件：swiftc -emit-sil main.swift | xcrun swift-demangle

来到Week.init(rawValue:)方法

Swift底层进阶--010：枚举_第7张图片
init

来到bb1方法

Swift底层进阶--010：枚举_第8张图片
bb1

从bb1至bb14，将所有字符串存储到数组内，进行case匹配

Swift底层进阶--010：枚举_第9张图片
bb14

通过源码查看_findStringSwitchCase方法，两个入参分别是数组和需要匹配的字符串，然后遍历数组，如果匹配成功返回对应index，如果匹配失败返回-1

Swift底层进阶--010：枚举_第10张图片
_findStringSwitchCase

bb15匹配成功，直接跳转bb29。bb16匹配失败，继续后续的匹配

Swift底层进阶--010：枚举_第11张图片
bb15、bb16

bb28全部匹配失败，构建一个.none类型的Optional返回，就是nil。bb29匹配成功，构建一个.some类型的Optional返回，就是对应的枚举值

Swift底层进阶--010：枚举_第12张图片
bb28、bb29

关联值枚举

如果想⽤枚举表达更复杂的信息，⽽不仅仅是⼀个rawValue这么简单，这个时候可以使⽤关联值

enum Shape {
    case circle(radious: Double)
    case rectangle(width: Int, height: Int)
}

关联值枚举，没有rawValue属性。因为关联值枚举可以使用单个值或一组值来表示，但rawValue只能针对单个值

将上述代码生成SIL文件：swiftc -emit-sil main.swift | xcrun swift-demangle

Swift底层进阶--010：枚举_第13张图片
关联值枚举
只有 case和关联值，没有 typealias取别名，没有 init方法，没有 rawValue计算属性

关联值枚举可以省略关联值的标签，例如radious、width、height，但并不推荐这种书写方式，因为可读性太差

enum Shape {
    case circle(Double)
    case rectangle(Int, Int)
}

关联值枚举的使用

//创建
var circle = Shape.circle(radious: 10.0)
//重新分配
circle=Shape.circle(radious: 20.0)
模式匹配

使⽤switch匹配enum的时候，必须列举当前所有可能的情况，否则编译报错

Swift底层进阶--010：枚举_第14张图片
编译报错

匹配enum可以列举出所有情况，也可以使用default表示默认情况

enum Week: String {
    case MON = "MON"
    case TUE = "TUE"
    case WED = "WED"
    case THU = "THU"
    case FRI = "FRI"
    case SAT = "SAT"
    case SUN = "SUN"
}

var week: Week?

switch week {
    case .MON:
        print(Week.MON.rawValue)
    default:
        print("unknow day")
}

将上述代码生成SIL文件：swiftc -emit-sil main.swift | xcrun swift-demangle

Swift底层进阶--010：枚举_第15张图片
SIL

匹配关联值枚举
  • 方式一：通过switch匹配所有case 
enum Shape {
    case circle(radious: Double)
    case rectangle(width: Int, height: Int)
}

var shape = Shape.circle(radious: 10.0)

switch shape {
    case let .circle(radious):
        print("circle-radious：\(radious)")
    case let .rectangle(width, height):
        print("rectangle-width：\(width)，height：\(height)")
}

//输出以下内容：
//circle-radious：10.0

case let .circle(radious)相当于做了value-binding，如果case匹配上，相当于把10.0赋值给常量radious

另一种写法：将关联值的参数使用let、var修饰

switch shape {
    case .circle(var radious):
        print("circle-radious：\(radious)")
    case .rectangle(let width, let height):
        print("rectangle-width：\(width)，height：\(height)")
}

通过SIL代码，查看关联值枚举的匹配模式

enum Shape {
    case circle(radious: Double)
    case rectangle(width: Int, height: Int)
}

var shape = Shape.circle(radious: 10.0)

var temR: Double
var w: Int
var h: Int

switch shape {
    case .circle(let radious):
        temR=radious
    case .rectangle(let width, let height):
        w=width
        h=height
}

将上述代码生成SIL文件：swiftc -emit-sil main.swift | xcrun swift-demangle

Swift底层进阶--010：枚举_第16张图片
main

Swift底层进阶--010：枚举_第17张图片
bb1

  • 方式二：通过单个case进行匹配
enum Shape {
    case circle(radious: Double)
    case rectangle(width: Int, height: Int)
}

var shape = Shape.circle(radious: 10.0)

if case let Shape.circle(radious) = shape {
    print("circle-radious：\(radious)")
}

//输出以下内容：
//circle-radious：10.0
匹配不同枚举值的相同关联值
enum Shape {
    case circle(radious: Double, diameter: Double)
    case rectangle(width: Double, height: Double)
    case square(width: Double, width: Double)
}

var shape = Shape.circle(radious: 10.0, diameter: 20.0)

switch shape {
    case let .circle(x, 20.0), let .square(x, 20.0):
        print("x：\(x)")
    default:
        print("default")
}

//输出以下内容：
//x：10.0

上述代码，将多个枚举值中，我们想要匹配的关联值用x代替。如果枚举值为circle或square，且第二个关联值为20.0，即为匹配成功

通过SIL代码，查看不同枚举值的相同关联值是如何匹配的

enum Shape {
    case circle(radious: Double, diameter: Double)
    case rectangle(width: Double, height: Double)
    case square(width: Double, width: Double)
}

var shape = Shape.circle(radious: 10.0, diameter: 20.0)

var tmpR: Double

switch shape {
    case let .circle(x, 20.0), let .square(x, 20.0):
        tmpR=x
    default:
        print("default")
}

将上述代码生成SIL文件：swiftc -emit-sil main.swift | xcrun swift-demangle

Swift底层进阶--010：枚举_第18张图片
main

Swift底层进阶--010：枚举_第19张图片
bb1、bb2、bb3

不同枚举值里，用到匹配的变量或常量x，必须名称相同，不能一个用x一个用y，否则编译报错

编译报错

使用通配符_方式匹配

enum Shape {
    case circle(radious: Double, diameter: Double)
    case rectangle(width: Double, height: Double)
    case square(width: Double, width: Double)
}

var shape = Shape.circle(radious: 10.0, diameter: 30.0)

switch shape {
    case let .circle(x, _), let .square(x, _):
        print("x：\(x)")
    default:
        print("default")
}

//输出以下内容：
//x：10.0

上述代码，我们不关心第二个关联值是什么，可以使用通配符_代替。如果枚举值为circle或square，第二个关联为任意值，都能匹配成功

同样使用单个case进行匹配，也可以使用通配符_

var shape = Shape.circle(radious: 10.0, diameter: 20.0)

if case let Shape.circle(x, _) = shape{
    print("x：\(x)")
}

//输出以下内容：
//x：10.0
枚举嵌套
enum CombineDirect{
    enum BaseDirect{
        case up
        case down
        case left
        case right
    }

    case leftUp(baseDirect1: BaseDirect, baseDirect2: BaseDirect)
    case rightUp(baseDirect1: BaseDirect, baseDirect2: BaseDirect)
    case leftDown(baseDirect1: BaseDirect, baseDirect2: BaseDirect)
    case rightDown(baseDirect1: BaseDirect, baseDirect2: BaseDirect)
}

var combind = CombineDirect.leftDown(baseDirect1: .left, baseDirect2: .down)

上述代码，通过BaseDirect枚举的up、down、left、right四个case，组合出CombineDirect枚举中leftUp、rightUp、leftDown、rightDown四个case。这种方式下BaseDirect枚举相当于是私有的，外界无法直接访问

结构体中嵌套枚举
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 .up,.down:
                print("up, down")
        }
    }
}

let kill = Skill.init(key: .up)
kill.launchSkill()

//输出以下内容：
//up, down
枚举中包含属性

enum中能包含计算属性，类型属性，不能包含存储属性

enum Shape {

    case circle(radius: Double)
    case rectangle(width: Double, height: Double)

    var width: Double{
        get{
            return 10.0
        }
    }

    static let height = 20.0
}

enum中包含存储属性，编译报错

Swift底层进阶--010：枚举_第20张图片
编译报错

结构体可以包含存储属性，因为结构体的大小就是存储属性的大小。但 enum大小取决于 case的个数，只要 case个数没有超过 255， enum的大小就是 1字节

  • 计算属性本质是get、set方法，对于值类型来说根本不用存储方法
  • 类型属性是全局变量，它的存储也和enum没有任何关系
枚举中包含⽅法

可以在enum中定义实例⽅法，static修饰的⽅法

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)!
        }
    }
}

var week: Week = .SUN
week.nextDay()

print(week)

在enum的nextDay方法中修改自身，需要使用mutating关键字修饰

枚举的大小

rawValue枚举值大小

enum NoMean{
    case a
}

print("stride：\(MemoryLayout.stride)")
print("size：\(MemoryLayout.size)")

//输出以下内容：
//stride：1
//size：0

enum中只有一个case，大小为0，步长为1。当只有一个case的枚举，大小为0表示这个enum是没有意义的

enum NoMean{
    case a
    case b
}

print("stride：\(MemoryLayout.stride)")
print("size：\(MemoryLayout.size)")

//输出以下内容：
//stride：1
//size：1

enum中有两个case，大小为1，步长为1

enum NoMean{
    case a
    case b
    case c
    case d
    case e
}

print("stride：\(MemoryLayout.stride)")
print("size：\(MemoryLayout.size)")

//输出以下内容：
//stride：1
//size：1

enum中存在更多case，依然是大小为1，步长为1

将枚举值a、b、c赋值给三个常量

Swift底层进阶--010：枚举_第21张图片
赋值

通过断点查看汇编代码，分析枚举值a、b、c

Swift底层进阶--010：枚举_第22张图片
汇编代码
通过断点可以看出 a、 b、 c分别是 0x0、 0x1、 0x2，对系统来说就是 0、 1、 2。所以 rawValue枚举值默认是 UInt8类型，占 1字节，最大可以存储 255。超过 255个枚举值，系统会将 UInt8升级为 UInt16、 UInt32、 UInt64

通过lldb查看内存

Swift底层进阶--010：枚举_第23张图片
lldb
当前枚举的步⻓是 1字节，也就意味着如果在内存中连续存储 NoMean，需要跨越 1字节的⻓度。 1字节也就是 8 位，最⼤可以表达的数字是 255

关联值枚举的大小

enum Shape {
    case circle(radius: Double)
    case rectangle(width: Double, height: Double)
}

print("stride：\(MemoryLayout.stride)")
print("size：\(MemoryLayout.size)")

//输出以下内容：
//stride：24
//size：17

关联值枚举⼤⼩，取决于最⼤关联值⼤⼩，并加上1字节枚举值大小。

  • circle有一个Double类型关联值，占8字节
  • rectangle有两个Double类型关联值，占16字节
  • enum的大小，就是最大关联值16字节，再加枚举值1字节，共占17字节
  • stride由于8字节对齐，所以自动补齐到24字节

通过lldb查看内存

Swift底层进阶--010：枚举_第24张图片
lldb

枚举嵌套的大小

enum CombineDirect{
    enum BaseDirect{
        case up
        case down
        case left
        case right
    }

    case leftUp(baseDirect1: BaseDirect, baseDirect2: BaseDirect)
    case rightUp(baseDirect1: BaseDirect, baseDirect2: BaseDirect)
    case leftDown(baseDirect1: BaseDirect, baseDirect2: BaseDirect)
    case rightDown(baseDirect1: BaseDirect, baseDirect2: BaseDirect)
}

print("stride：\(MemoryLayout.stride)")
print("size：\(MemoryLayout.size)")

//输出以下内容：
//stride：2
//size：2

枚举嵌套和关联值枚举一样，同样取决于关联值大小

通过lldb查看内存

Swift底层进阶--010：枚举_第25张图片
lldb

  • BaseDirect中的up、down、left、right对应的枚举值分别为0、1、2、3
  • CombineDirect中的leftUp、rightUp、leftDown、rightDown对应的枚举值分别为0、4、8、12。这里并没有规律可寻，如果加入更多case，也会变成0、1、2、3...向后递增，通过源码分析目前还未找到相关定义
  • 图中输出的02是left的枚举值，81要拆开来看，8是leftDown的枚举值，1是down的枚举值
  • enum大小占2字节，因为leftDown的枚举值和down的枚举值存储在同一字节内，属于系统优化

结构体中嵌套枚举的大小

struct Skill{
    enum KeyType{
        case up
        case down
        case left
        case right
    }

    let key: KeyType
}

print("stride：\(MemoryLayout.stride)")
print("size：\(MemoryLayout.size)")

//输出以下内容：
//stride：1
//size：1

结构体中有一个KeyType枚举类型的成员变量key，所以结构体大小为1，步长为1

indirect关键字

如果想要表达的enum是⼀个复杂的关键数据结构，可以通过indrect关键字让当前的enum更简洁

创建链表结构enum，对应当前递归枚举来说，不添加indirect关键字，编译报错

编译报错

因为enum是值类型，它会在编译时期确定大小。但对于接收泛型T的enum，编译时期无法确定enum大小，系统无法分配空间

enum List{
    case end
    indirect case node(T, next: List)
}

上述代码，在case node前面添加indirect关键字，可以编译通过

indirect enum List{
    case end
    case node(T, next: List)
}

另一种方式，可以在enum List前面添加indirect关键字，同样可以编译通过

indirect enum List{
    case end
    case node(T, next: List)
}

print("List stride：\(MemoryLayout>.stride)")
print("List size：\(MemoryLayout>.size)")

print("List stride：\(MemoryLayout>.stride)")
print("List size：\(MemoryLayout>.size)")

上述代码，分别将Int和String传入enum，打印出来的大小都是8字节，下面来分析一下原因

通过lldb查看内存
打印case end，存储的是end枚举值

Swift底层进阶--010：枚举_第26张图片
end

打印case node，存储的是堆区地址

Swift底层进阶--010：枚举_第27张图片
node

indirect关键字本质就是通知编译器，当前enum是递归枚举，无法确定大小，需要在堆区空间分配内存，并存储enum

通过SIL代码，查看indirect关键字，如何分配堆区内存空间

indirect enum List{
    case end
    case node(T, next: List)
}

var node = List.node(10, next: List.end)

将上述代码生成SIL文件：swiftc -emit-sil main.swift | xcrun swift-demangle

Swift底层进阶--010：枚举_第28张图片
main

通过断点查看汇编代码，确实执行了swift_allocObject

Swift底层进阶--010：枚举_第29张图片
lldb

枚举-Swift和OC混编
OC调用Swift的枚举

OC只能调用Swift中Int类型枚举

@objc enum NoMean: Int{
    case a
    case b
    case c
    case d
}

通过@objc声明后，桥接文件中自动生成SWIFT_ENUM

typedef SWIFT_ENUM(NSInteger, NoMean, closed) {
  NoMeanA = 0,
  NoMeanB = 1,
  NoMeanC = 2,
  NoMeanD = 3,
};

在OC的LGTest.m文件中可以直接调用

@implementation LGTest

- (void)test{
    NoMean a = NoMeanA;
}

@end

如果enum不声明类型，同时使用@objc修饰，编译报错

Swift底层进阶--010：枚举_第30张图片
不声明类型

如果enum声明String类型，同时使用@objc修饰，编译报错

Swift底层进阶--010：枚举_第31张图片
声明String类型

Swift调用OC的枚举

OC的LGTest.h中，使用typedef NS_ENUM声明枚举

typedef NS_ENUM(NSInteger, CEnum) {
    CEnumInvalid = 0,
    CEnumA = 1,
    CEnumB,
    CEnumC
};

在桥接文件中，自动生成enum CEnum

public enum CEnum : Int {
    case invalid = 0
    case A = 1
    case B = 2
    case C = 3
}

OC的LGTest.h中，使用typedef enum声明枚举

typedef enum{
    Num1,
    Num2
} OCNum;

在桥接文件中，自动生成struct OCNum，变成了结构体，并遵循了 Equatable和RawRepresentable协议

public struct OCNum : Equatable, RawRepresentable {
    public init(_ rawValue: UInt32)
    public init(rawValue: UInt32)
    public var rawValue: UInt32
}

在Swift的main.swift文件中可以直接调用

let a: CEnum = .A
let b: OCNum = OCNum.init(rawValue: 1)

print("CEnum：\(a.rawValue)")
print("OCNum：\(b.rawValue)")

//输出以下内容：
//CEnum：1
//OCNum：1
内存对齐 & 字节对齐
  • 内存对齐：iOS采用8字节对齐方式，只会在对象初始化分配内存时出现。例如malloc、calloc
  • 字节对齐：第一个数据成员放在offset为0的位置，以后每个数据成员存储的起始位置要从该成员大小或该成员的子成员大小（只要该成员有子成员，比如数组、结构体等）的整数倍开始。比如Int为8字节，则要从8的整数倍地址开始存储
enum Shape {
    case circle(radius: Double)
    case rectangle(width: Int8, height: Int, w: Int16, h: Int32)
}

print("stride：\(MemoryLayout.stride)")
print("size：\(MemoryLayout.size)")

//输出以下内容：
//stride：24
//size：24
  • width：Int8类型，占1字节
  • height：Int类型，占8字节
  • w：Int16类型，占2字节
  • h：Int32类型，占4字节
  • width占1字节，但第二成员height占8字节。按字节对齐规则，height起始位置必须是自身的整数倍，所以width要补齐到8字节。而w占2字节，但h占4字节，所以同理w要补齐到4字节。最终size大小：8 + 8 + 4 + 4 = 24字节

你可能感兴趣的:(Swift底层进阶--010：枚举)

  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说 造命者说
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
  • 第四天旅游线路预览——从换乘中心到喀纳斯湖 陟彼高冈yu 基于Googleearthstudio的旅游规划和预览旅游
    第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
  • Goolge earth studio 进阶4——路径修改与平滑 陟彼高冈yu Googleearthstudio进阶教程旅游
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • xilinx vivado PULLMODE 设置思路 坚持每天写程序 fpga开发
    1.xilinx引脚分类XilinxIO的分类：以XC7A100TFGG484为例，其引脚分类如下：1.UserIO(用户IO)：用户使用的普通IO1.1专用(Dedicated)IO：命名为IO_LXXY_#、IO_XX_#的引脚，有固定的特定用途，多为底层特定功能的直接实现，如差分对信号、关键控制信号等，不能随意变更。1.2多功能(Multi-Function)IO：命名为IO_LXXY_ZZ
  • 如何在心上用功？ 余超林AIA财富管家
    思考：如何在心上用功？学习心得：心-道-德-事的理解心-道-德-事这四部曲，本质上就是一个人的思维智慧的四个层面：事是最底层，这是所有人在这个社会谋求生存的基础，一个人能够把事情彻底做好，保质保量的完成，才会有真正的结果，但是这个层面要获得真正成功很困难，因为会做事的人很多，最终会出现恶性竞争；德是第三层，如果说整个社会做事的竞争激烈程度为100%，那么上升到德上的竞争激烈程度降低为80%，德是一
  • 新私域是什么平台靠谱吗 氧惠佣金真的高
    新私域指的是借助与互联网电商，随着平台内商家入驻量、用户量相辅相成的全国化平台。是否靠谱取决于平台是否合规。新私域指的是借助与互联网电商，在传统会员体系外新增的锁定用户跨平台、跨界收益，一种随着平台内商家入驻量、用户量相辅相成的全国化平台。关于新私域平台是否靠谱，这个需要看平台的底层逻辑是否合理、合法、合规以及平台的未来的发展方向氧惠APP抖音购物、看电影、点外卖、打车用氧惠APP！佣金更高、更优
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • 2023-08-20 圆梦菌
    魔力宝贝最详细新手教程，新手该如何完美开局，建议收藏转发2023-08-2010:34《魔力宝贝》手游体力是什么?魔力宝贝体力恢复机制是每10分钟回复1点；体力作用：挑战关卡需消耗体力体力获取方式1、好友每天可以赠送15次，也就是15点体力2、系统每天中午12点以及下午6点赠送25体3、在商城使用神石购买《魔力宝贝》手游战斗力如何提升?1、宠物强化宠物通过融合进阶后可以大幅度提升战力，最高级的宠物
  • 258-各位相加 不胖二十斤不改名zz
    给定一个非负整数num，反复将各个位上的数字相加，直到结果为一位数。输入:38输出:2解释:各位相加的过程为：3+8=11,1+1=2。由于2是一位数，所以返回2。最简单的方法就是递归了。进阶:你可以不使用循环或者递归，且在O(1)时间复杂度内解决这个问题吗？假如一个三位数'abc'，其值大小为s1=100*a+10*b+1*c，经过一次各位相加后，变为s2=a+b+c，减小的差值为(s1-s2)
  • 李克富 | 咨询师推荐阅读书目 李克富
    最重要的书籍不是别人的推荐，而是自己学过的教材，不论当初使用的是哪个版本，它都是我们专业的底层代码，具有不可替代性。前不久，中国心理咨询师筹委会的一位老师邀请我罗列一个推荐书目清单作为咨询师工具包的内容，并要求“说明一下简单的分类或者作三言两语的说明”。斟酌后，我觉得自己推荐的书目大体可以分为普及类书籍、心理学书籍和心理咨询与治疗专业书籍，第三类又分为适合于咨询师新手的和有经验咨询师的。经过严格筛
  • Python编程 - 函数进阶 易辰君 Python核心编程python开发语言
    目录前言一、函数参数的高级用法（一）缺省参数（二）命名参数（三）不定长参数二、拆包（一）函数返回值拆包（二）通过星号拆包（三）总结三、匿名函数（一）函数定义（二）使用匿名函数四、递归函数（一）简介（二）基本结构（三）简单示例（四）优缺点总结前言上篇文章主要了解了函数基础，如何定义函数，函数种类以及局部变量和全局变量的差异等，接下来就讲解python函数较为进阶的知识点，若有任何想法欢迎一起沟通讨论
  • 底层逻辑之复利 音匀的生活札记
    本金↑（1+收益率）时间-欲望=财富自由理解了真正的“复利公式”，以及获得财富自由的三种方法——“无欲无求式财富自由”“三生三世式财富自由”和“第一桶金式财富自由”后，得出结论：早期靠本金，后期靠复利。最后，给大家几点建议：一是尽早存到足够的本金。获得财富自由的第一重要的事，是培养赚钱的能力。赚钱要靠本金，而不是靠复利。你都没有本金，哪来的钱生钱呢？二是努力做到稳健高收益。找到高收益的投资不难，识
  • [Swift]LeetCode943. 最短超级串 | Find the Shortest Superstring 黄小二哥 swift
    ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★➤微信公众号：山青咏芝（shanqingyongzhi）➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）➤GitHub地址：https://github.com/strengthen/LeetCode➤原文地址：https://www.cnblogs.com/streng
  • [Swift]LeetCode767. 重构字符串 | Reorganize String weixin_30591551 swiftruntime
    ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★➤微信公众号：山青咏芝（shanqingyongzhi）➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）➤GitHub地址：https://github.com/strengthen/LeetCode➤原文地址：https://www.cnblogs.com/streng
  • leetcode刷题day19|二叉树Part07（235. 二叉搜索树的最近公共祖先、701.二叉搜索树中的插入操作、450.删除二叉搜索树中的节点） 小冉在学习 leetcode算法数据结构
    235.二叉搜索树的最近公共祖先思路：二叉搜索树首先考虑中序遍历。根据二叉搜索树的特性，如果p,q分别在中间节点的左右两边，该中间节点一定是最近公共祖先，如果在同一侧，则递归这一侧即可。递归三部曲：1、传入参数：根节点，p，q，返回节点。2、终止条件：因为p,q一定存在，所以不会遍历到树的最底层，因此可以不写终止条件3、递归逻辑：如果p,q均小于root的值，递归调用左子树；如果p,q均大于roo
  • 教师资格证常考的5个知识点 a3cb74a20840
    知识点1：教育与人的发展(5规律、4因素、3动因)五大规律：顺序性—循序渐进阶段性—不搞“一刀切”不平衡性—抓关键期互补性—扬长避短个别差异性—因材施教考点精华：1.举例子对应五大规律;2.每个规律的教学启示;3规律特点。四大因素：遗传(地位：物质前提、可能性)环境(地位：多种可能、现实性)学校教育(主导)个人主观能动性(动力、决定)三大动因：内发论(1.孟子：性善论;2.弗洛伊德：性本能)外铄论
  • 【C语言】- 自定义类型：结构体、枚举、联合 Cavalier_01 C语言
    【C语言】：操作符（https://mp.csdn.net/editor/html/115218055）数据类型（https://mp.csdn.net/editor/html/115219664）自定义类型：结构体、枚举、联合（https://mp.csdn.net/editor/html/115373785）变量、常量（https://mp.csdn.net/editor/html/11523
  • PCIe进阶之TL：Memory, I/O, and Configuration Request Rules & TPH Rules 芯芯之火，可以燎原 PCIe进阶PCIe进阶硬件工程信息与通信
    1Memory,I/O,andConfigurationRequestRules下述规则适用于Memory请求、IO请求和配置请求。除了公共的header字段外，所有Memory请求、IO请求和配置请求还包括以下字段：（1）RequesterID[15:0]和Tag[9:0]，组成了TransactionID。（2）LastDWBE[3:0]和1stDWBE[3:0]字段。对于TH字段置1的Mem
  • Go编程语言前景怎么样？参加培训好就业吗 QFdongdong
    Go语言专门针对多处理器系统应用程序的编程进行了优化，使用Go编译的程序可以媲美C或C++代码的速度，而且更加安全、支持并行进程。不仅可以开发web,可以开发底层，目前知乎就是用golang开发。区块链首选语言就是go,以-太坊，超级账本都是基于go语言，还有go语言版本的btcd.Go的目标是希望提升现有编程语言对程序库等依赖性(dependency)的管理，这些软件元素会被应用程序反复调用。由
  • 2. 变量和指令（omron 机器自动化控制器）——1 一半不眠次日si记 OMRONNJ/NX系列PLC指令基准手册自动化运维
    机器自动化控制器——第二章变量和指令12-1变量一览表MC通用变量轴变量▶轴组变量运动控制指令的输入变量输入变量的有效范围▶枚举体一览表运动控制指令的输出变量运动控制指令的输入输出变量2-1变量一览表MC功能模块使用的变量分为两类。一类是监视轴等的状态及部分参数设定内容的系统定义变量。MC功能模块使用的系统定义变量被称作运动控制系统变量。还有一类是运动控制指令将指令的自变量作为输入接收、将指令的执
  • 职业生涯路上，停下来调整步伐是必要的～～【19/100】 墨妈翔爹
    决定离辞的时候，我都没能想明白我当时是理智的作出决定，还是仅仅因为被焦虑所干扰而作出的逃避性的选择。不记得是哪天，跟朋友聊了一下当下的工作现状，和今后各自的职业规划和发展前景。然后发现自己经毕业出来7年了，却依然还处于职业生涯的底层，在我们这个小县城里领着两三千的工资，而朋友已经后来居上仅仅用了三年时间就完成了弯道超车(前四年一直在醉心于创业)，不论是工作业务能力还是薪水都已经远远的超过了我。在备
  • Lua 与 C#交互 z2014z luac#开发语言
    Lua与C#交互前提Lua是一种嵌入式脚本语言，Lua的解释器是用C编写的，因此可以方便的与C/C++进行相互调用。轻量级Lua语言的官方版本只包括一个精简的核心和最基本的库，这使得Lua体积小、启动速度快，也适合嵌入在别的程序里。交互过程C#调用Lua:由C#文件调用Lua解析器底层dll库（由C语言编写），再由dll文件执行相应的Lua文件。Lua调用C#：1、Wrap方式：首先生成C#源文件
  • C# 开发教程-入门基础 天马3798 教程系列整理c#开发语言
    1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
  • 2018-08-16【Swift 4.1】 关于Swift4.0以后调用MJExtension无法模型转换问题 码农happy
    1、本人使用swift4.1，弄了一晚上才弄好，结果还是一个小问题真是尴尬，要在model中每个属性前面加上@objcimportUIKitclassUserModel:NSObject{@objcvardix=String()}letdic=["dix":"ffffff"]asNSDictionaryletmodel=UserModel.mj_object(withKeyValues:dic)!
  • java的四个层级结构 活跃家族 JAVA
    java的四个层级结构首先，最底层的就是dto层，dto层就是所谓的model，dto中定义的是实体类，也就是.class文件，该文件中包含实体类的属性和对应属性的get、set方法；其次，是dao层（dao层的文件习惯以*Mapper命名），dao层会调用dto层，dao层中会定义实际使用到的方法，比如增删改查。一般在dao层下还会有个叫做sqlmap的包，该包下有xml文件，文件内容正是根据之
  • 后端开发刷题 | 最长回文子串 jingling555 笔试题目java算法javascript数据结构后端
    描述对于长度为n的一个字符串A（仅包含数字，大小写英文字母），请设计一个高效算法，计算其中最长回文子串的长度。数据范围：1≤n≤1000要求：空间复杂度O(1)，时间复杂度O(n2)进阶:空间复杂度O(n)，时间复杂度O(n)示例1输入："ababc"返回值：3说明：最长的回文子串为"aba"与"bab"，长度都为3示例2输入："abbba"返回值：5示例3输入："b"返回值：1思路分析：该题可以
  • 磁盘性能评价指标—IOPS和吞吐量 ???? ??? Frank
    一、磁盘I/O的概念I/O的概念，从字义来理解就是输入输出。操作系统从上层到底层，各个层次之间均存在I/O。比如，CPU有I/O，内存有I/O,VMM有I/O,底层磁盘上也有I/O，这是广义上的I/O。通常来讲，一个上层的I/O可能会产生针对磁盘的多个I/O，也就是说，上层的I/O是稀疏的，下层的I/O是密集的。磁盘的I/O，顾名思义就是磁盘的输入输出。输入指的是对磁盘写入数据，输出指的是从磁盘读
  • ODOO不同版本与平台选择 chouchengyin2080 c#操作系统运维
    1.10.0vs11.0vs8.0截至2017年底，最新的ODOO发布版为ODOO11.0，但功能上有一定精简（去除财务模块，去除工作流支持），技术上变动较大（代码逐步迁移至Python3，前端框架改写得抽象）。所以如果是从生产使用的角度来讲，ODOO10.0是当前最好选择，因为其更稳定，第三方模块也更多更全面。而如果是ODOO技术爱好从业者，则逐步迁移至ODOO11.0也有必要，因为其底层技术架
  • malloc和new的区别及联系 月夜星辉雪 数据结构
    一.区别1.用法上malloc是一个函数，而new是C++一个操作符malloc需要手动计算开辟的空间大小，new后面只需跟上空间的类型，如果有多个对象，加上[]给个数即可malloc申请的空间不能初始化，而new可以malloc返回void*，需要强制类型转换，而new返回对应类型的指针malloc失败会返回空指针，需要手动检查；new失败抛出异常，要用catch捕获2.底层原理上申请自定义类型
  • 对股票分析时要注意哪些主要因素？ 会飞的奇葩猪 股票 分析 云掌股吧
    　　众所周知，对散户投资者来说，股票技术分析是应战股市的核心武器，想学好股票的技术分析一定要知道哪些是重点学习的，其实非常简单，我们只要记住三个要素：成交量、价格趋势、振荡指标。     一、成交量 　　大盘的成交量状态。成交量大说明市场的获利机会较多，成交量小说明市场的获利机会较少。当沪市的成交量超过150亿时是强市市场状态，运用技术找综合买点较准；
  • 【Scala十八】视图界定与上下文界定 bit1129 scala
    Context Bound，上下文界定，是Scala为隐式参数引入的一种语法糖，使得隐式转换的编码更加简洁。   隐式参数 首先引入一个泛型函数max，用于取a和b的最大值 def max[T](a: T, b: T) = { if (a > b) a else b }  因为T是未知类型，只有运行时才会代入真正的类型，因此调用a >
  • C语言的分支——Object-C程序设计阅读有感 darkblue086 applec框架cocoa
    自从1972年贝尔实验室Dennis Ritchie开发了C语言，C语言已经有了很多版本和实现，从Borland到microsoft还是GNU、Apple都提供了不同时代的多种选择，我们知道C语言是基于Thompson开发的B语言的，Object-C是以SmallTalk-80为基础的。和C++不同的是，Object C并不是C的超集，因为有很多特性与C是不同的。 Object-C程序设计这本书
  • 去除浏览器对表单值的记忆 周凡杨 html记忆autocompleteform浏览
                                       &n
  • java的树形通讯录 g21121 java
    最近用到企业通讯录，虽然以前也开发过，但是用的是jsf，拼成的树形，及其笨重和难维护。后来就想到直接生成json格式字符串，页面上也好展现。 // 首先取出每个部门的联系人 for (int i = 0; i < depList.size(); i++) { List<Contacts> list = getContactList(depList.get(i
  • Nginx安装部署 510888780 nginxlinux
    Nginx ("engine x") 是一个高性能的 HTTP 和 反向代理 服务器，也是一个 IMAP/POP3/SMTP 代理服务器。 Nginx 是由 Igor Sysoev 为俄罗斯访问量第二的 Rambler.ru 站点开发的，第一个公开版本0.1.0发布于2004年10月4日。其将源代码以类BSD许可证的形式发布，因它的稳定性、丰富的功能集、示例配置文件和低系统资源
  • java servelet异步处理请求 墙头上一根草 ｊａｖａ异步返回ｓｅｒｖｌｅｔ
    servlet3.0以后支持异步处理请求，具体是使用AsyncContext ，包装httpservletRequest以及httpservletResponse具有异步的功能，        final AsyncContext ac = request.startAsync(request, response);   ac.s
  • 我的spring学习笔记8-Spring中Bean的实例化 aijuans Spring 3
    在Spring中要实例化一个Bean有几种方法： 1、最常用的（普通方法） <bean id="myBean" class="www.6e6.org.MyBean" /> 使用这样方法，按Spring就会使用Bean的默认构造方法，也就是把没有参数的构造方法来建立Bean实例。 （有构造方法的下个文细说） 2、还
  • 为Mysql创建最优的索引 annan211 mysql索引
    索引对于良好的性能非常关键，尤其是当数据规模越来越大的时候，索引的对性能的影响越发重要。 索引经常会被误解甚至忽略，而且经常被糟糕的设计。 索引优化应该是对查询性能优化最有效的手段了，索引能够轻易将查询性能提高几个数量级，最优的索引会比 较好的索引性能要好2个数量级。 1 索引的类型 (1) B-Tree 不出意外，这里提到的索引都是指 B-
  • 日期函数 百合不是茶 oraclesql日期函数查询
      ORACLE日期时间函数大全 TO_DATE格式(以时间:2007-11-02 13:45:25为例) Year: yy two digits 两位年 显示值:07 yyy three digits 三位年 显示值:007
  • 线程优先级 bijian1013 javathread多线程java多线程
    多线程运行时需要定义线程运行的先后顺序。 线程优先级是用数字表示，数字越大线程优先级越高，取值在1到10，默认优先级为5。 实例： package com.bijian.study; /** * 因为在代码段当中把线程B的优先级设置高于线程A,所以运行结果先执行线程B的run()方法后再执行线程A的run()方法 * 但在实际中，JAVA的优先级不准，强烈不建议用此方法来控制执
  • 适配器模式和代理模式的区别 bijian1013 java设计模式
    一.简介        适配器模式：适配器模式（英语：adapter pattern）有时候也称包装样式或者包装。将一个类的接口转接成用户所期待的。一个适配使得因接口不兼容而不能在一起工作的类工作在一起，做法是将类别自己的接口包裹在一个已存在的类中。      &nbs
  • 【持久化框架MyBatis3三】MyBatis3 SQL映射配置文件 bit1129 Mybatis3
     SQL映射配置文件一方面类似于Hibernate的映射配置文件，通过定义实体与关系表的列之间的对应关系。另一方面使用<select>,<insert>,<delete>，<update>元素定义增删改查的SQL语句， 这些元素包含三方面内容 1. 要执行的SQL语句 2. SQL语句的入参，比如查询条件 3. SQL语句的返回结果
  • oracle大数据表复制备份个人经验 bitcarter oracle大表备份大表数据复制
    前提：    数据库仓库A（就拿oracle11g为例）中有两个用户user1和user2,现在有user1中有表ldm_table1,且表ldm_table1有数据5千万以上，ldm_table1中的数据是从其他库B（数据源）中抽取过来的，前期业务理解不够或者需求有变，数据有变动需要重新从B中抽取数据到A库表ldm_table1中。    
  • HTTP加速器varnish安装小记 ronin47 http varnish 加速
    上午共享的那个varnish安装手册，个人看了下，有点不知所云，好吧~看来还是先安装玩玩！ 苦逼公司服务器没法连外网，不能用什么wget或yum命令直接下载安装，每每看到别人博客贴出的在线安装代码时，总有一股羡慕嫉妒“恨”冒了出来。。。好吧，既然没法上外网，那只能麻烦点通过下载源码来编译安装了！ Varnish 3.0.4下载地址： http://repo.varnish-cache.org/
  • java-73-输入一个字符串，输出该字符串中对称的子字符串的最大长度 bylijinnan java
    public class LongestSymmtricalLength { /* * Q75题目：输入一个字符串，输出该字符串中对称的子字符串的最大长度。 * 比如输入字符串“google”，由于该字符串里最长的对称子字符串是“goog”，因此输出4。 */ public static void main(String[] args) { Str
  • 学习编程的一点感想 Cb123456 编程感想Gis
           写点感想，总结一些，也顺便激励一些自己.现在就是复习阶段，也做做项目.      本专业是GIS专业，当初觉得本专业太水，靠这个会活不下去的，所以就报了培训班。学习的时候，进入状态很慢，而且当初进去的时候，已经上到Java高级阶段了，所以.....，呵呵，之后有点感觉了，不过，还是不好好写代码，还眼高手低的，有
  • [能源与安全]美国与中国 comsci 能源
         现在有一个局面：地球上的石油只剩下N桶，这些油只够让中国和美国这两个国家中的一个顺利过渡到宇宙时代，但是如果这两个国家为争夺这些石油而发生战争，其结果是两个国家都无法平稳过渡到宇宙时代。。。。而且在战争中，剩下的石油也会被快速消耗在战争中，结果是两败俱伤。。。       在这个大
  • SEMI-JOIN执行计划突然变成HASH JOIN了 的原因分析 cwqcwqmax9 oracle
    甲说： A B两个表总数据量都很大，在百万以上。 idx1  idx2字段表示是索引字段 A B 两表上都有 col1字段表示普通字段 select xxx from A where A.idx1 between mmm and nnn      and exists (select 1 from B where B.idx2 =
  • SpringMVC-ajax返回值乱码解决方案 dashuaifu AjaxspringMVCresponse中文乱码
      SpringMVC-ajax返回值乱码解决方案   一：（自己总结，测试过可行） ajax返回如果含有中文汉字，则使用：（如下例：） @RequestMapping(value="/xxx.do")       public @ResponseBody void getPunishReasonB
  • Linux系统中查看日志的常用命令 dcj3sjt126com OS
    因为在日常的工作中，出问题的时候查看日志是每个管理员的习惯，作为初学者，为了以后的需要，我今天将下面这些查看命令共享给各位 cat tail -f 日 志 文 件 说 明 /var/log/message 系统启动后的信息和错误日志，是Red Hat Linux中最常用的日志之一 /var/log/secure 与安全相关的日志信息 /var/log/maillog 与邮件相关的日志信
  • [应用结构]应用 dcj3sjt126com PHPyii2
    应用主体 应用主体是管理 Yii 应用系统整体结构和生命周期的对象。 每个Yii应用系统只能包含一个应用主体，应用主体在 入口脚本中创建并能通过表达式 \Yii::$app 全局范围内访问。 补充: 当我们说"一个应用"，它可能是一个应用主体对象，也可能是一个应用系统，是根据上下文来决定[译：中文为避免歧义，Application翻译为应
  • assertThat用法 eksliang JUnitassertThat
    junit4.0  assertThat用法 一般匹配符1、assertThat( testedNumber, allOf( greaterThan(8), lessThan(16) ) ); 注释： allOf匹配符表明如果接下来的所有条件必须都成立测试才通过，相当于“与”（&&） 2、assertThat( testedNumber, anyOf( g
  • android点滴2 gundumw100 应用服务器android网络应用OSHTC
    如何让Drawable绕着中心旋转？ Animation a = new RotateAnimation(0.0f, 360.0f, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,0.5f); a.setRepeatCount(-1); a.setDuration(1000); 如何控制Andro
  • 超简洁的CSS下拉菜单 ini htmlWeb工作html5css
    效果体验：http://hovertree.com/texiao/css/3.htmHTML文件： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>简洁的HTML+CSS下拉菜单-HoverTree</title>
  • kafka consumer防止数据丢失 kane_xie kafkaoffset commit
    kafka最初是被LinkedIn设计用来处理log的分布式消息系统，因此它的着眼点不在数据的安全性（log偶尔丢几条无所谓），换句话说kafka并不能完全保证数据不丢失。   尽管kafka官网声称能够保证at-least-once，但如果consumer进程数小于partition_num，这个结论不一定成立。   考虑这样一个case，partiton_num=2
  • @Repository、@Service、@Controller 和 @Component mhtbbx DAOspringbeanprototype
    @Repository、@Service、@Controller 和 @Component 将类标识为Bean Spring 自 2.0 版本开始，陆续引入了一些注解用于简化 Spring 的开发。@Repository注解便属于最先引入的一批，它用于将数据访问层 (DAO 层 ) 的类标识为 Spring Bean。具体只需将该注解标注在 DAO类上即可。同时，为了让 Spring 能够扫描类
  • java 多线程高并发读写控制 误区 qifeifei java thread
    先看一下下面的错误代码，对写加了synchronized控制，保证了写的安全，但是问题在哪里呢？ public class testTh7 { private String data; public String read(){ System.out.println(Thread.currentThread().getName() + "read data "
  • mongodb replica set(副本集)设置步骤 tcrct javamongodb
    网上已经有一大堆的设置步骤的了，根据我遇到的问题，整理一下，如下： 首先先去下载一个mongodb最新版，目前最新版应该是2.6 cd /usr/local/bin wget http://fastdl.mongodb.org/linux/mongodb-linux-x86_64-2.6.0.tgz tar -zxvf mongodb-linux-x86_64-2.6.0.t
  • rust学习笔记 wudixiaotie 学习笔记
    1.rust里绑定变量是let，默认绑定了的变量是不可更改的，所以如果想让变量可变就要加上mut。 let x = 1; let mut y = 2; 2.match 相当于erlang中的case，但是case的每一项后都是分号，但是rust的match却是逗号。 3.match 的每一项最后都要加逗号，但是最后一项不加也不会报错，所有结尾加逗号的用法都是类似。 4.每个语句结尾都要加分
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他