Swift底層原理探索4----結構體和類

時間  2021-08-13
標籤 swift 安全 markdown app ide 函數 性能 spa 3d 欄目 Swift 简体版
原文   原文鏈接

結構體

  • 在Swift標準庫中，絕大多數公開類型都是結構體，而枚舉和類只佔很小的一部分

好比Bool、Int、Double、String、Array、Dictionary等常見類型都是結構體swift

struct Date {
    var year: Int
    var month: Int
    var day: Int
}
var date = Date(year: 2020, month:02, day:29)//編譯器爲結構體自動生成的初始化器
複製代碼

image

  • 全部的結構體都有一個編譯器自動生成的初始化器（initializer，初始化方法，構造器，構造方法）

在第⑥行調用的，能夠傳入全部成員值，用以初始化全部成員（存儲屬性，Stored Property）安全


結構體的初始化器

編譯器會根據狀況，可能會爲結構體生成多個初始化器，宗旨是：保證全部成員有初始值，保證代碼的安全，看一下以下幾種場景，報錯的緣由都是由於有成員變量沒有賦初始化值 在這裏插入圖片描述 在這裏插入圖片描述 在這裏插入圖片描述 下面這樣，就沒有問題markdown

struct Point {
    var x: Int = 0
    var y: Int = 0
}
var p1 = Point(x: 10, y: 10)
var p2 = Point(y: 10)
var p3 = Point(x: 10)
var p4 = Point()
複製代碼

再看一個場景app

struct Point {
    var x: Int?
    var y: Int?
}
var p1 = Point(x: 10, y: 10)
var p2 = Point(y: 10)
var p3 = Point(x: 10)
var p4 = Point()
複製代碼

因爲var x: Int? var y: Int?聲明以後，默認有初始值nil，所以也不會有上述的報錯ide


自定義初始化器

一旦在定義結構體時自定義了初始化器，編譯器就不會再幫它自動生成其餘初始化器函數

image


窺探初始化器的本質

下面是兩端等效的代碼，第一段使用了系統生成的無參初始化起，第二段使用了咱們自定義的無參初始化器性能

struct Point {
    var x: Int = 0
    var y: Int = 0
}
var p = Point()
複製代碼
struct Point {
    var x: Int
    var y: Int
    init() {
        x = 0
        y = 0
    }
}
var p = Point()
複製代碼

咱們分別來看一下他們的彙編代碼ui

func testStruct() {
    struct Point {
        var x: Int = 0
        var y: Int = 0
    }
    var p = Point() //在這裏加上斷點而且運行程序
}

testStruct()

***************彙編代碼
SwiftTest`init() in Point #1 in testStruct():
->  0x1000010b0 <+0>:  pushq  %rbp
    0x1000010b1 <+1>:  movq   %rsp, %rbp
    0x1000010b4 <+4>:  xorps  %xmm0, %xmm0
    0x1000010b7 <+7>:  movaps %xmm0, -0x10(%rbp)
    0x1000010bb <+11>: movq   $0x0, -0x10(%rbp)
    0x1000010c3 <+19>: movq   $0x0, -0x8(%rbp)
    0x1000010cb <+27>: xorl   %eax, %eax
    0x1000010cd <+29>: movl   %eax, %ecx
    0x1000010cf <+31>: movq   %rcx, %rax
    0x1000010d2 <+34>: movq   %rcx, %rdx
    0x1000010d5 <+37>: popq   %rbp
    0x1000010d6 <+38>: retq 
複製代碼
func testStruct() {
    struct Point {
        var x: Int
        var y: Int
        init() {
            x = 0
            y = 0
        }
    }
    var p = Point()  // 這裏加上斷點而且運行程序
}

testStruct()

***************彙編代碼
SwiftTest`init() in Point #1 in testStruct():
->  0x1000010b0 <+0>:  pushq  %rbp
    0x1000010b1 <+1>:  movq   %rsp, %rbp
    0x1000010b4 <+4>:  xorps  %xmm0, %xmm0
    0x1000010b7 <+7>:  movaps %xmm0, -0x10(%rbp)
    0x1000010bb <+11>: movq   $0x0, -0x10(%rbp)
    0x1000010c3 <+19>: movq   $0x0, -0x8(%rbp)
    0x1000010cb <+27>: xorl   %eax, %eax
    0x1000010cd <+29>: movl   %eax, %ecx
    0x1000010cf <+31>: movq   %rcx, %rax
    0x1000010d2 <+34>: movq   %rcx, %rdx
    0x1000010d5 <+37>: popq   %rbp
    0x1000010d6 <+38>: retq   
複製代碼

對比上述兩段程序，他們所調用的無參初始化器函數底層的彙編代碼是如出一轍的，所以判斷，是等效的。語法糖或許會騙人，但彙編永遠不會騙你。spa


結構體內存結構

struct Point {
    var x: Int = 10
    var y: Int = 20
    var origin: Bool = true
}
var p = Point()
print(MemoryLayout<Point>.size)
print(MemoryLayout<Point>.stride)
print(MemoryLayout<Point>.alignment)
print(Mems.memStr(ofVal: &p)) //輸出結構體內存裏面的數據

****************運行結果
17
24
8
0x000000000000000a 0x0000000000000014 0x0000000000000001
Program ended with exit code: 0
複製代碼

看得出，Swift的結構體和C語言的結構體內存結構是同樣的，成員變量內存都是緊挨在一塊兒的3d


類

類的定義和結構體相似，但編譯器並無爲類自動生成能夠傳入成員值的初始化器 image 在類的每一個成員都有默認值的狀況下，系統則會爲它建立一個無參初始化器 image 須要注意的是 var x: Int?是optional，所以它會自動得到一個默認值nil。相比較於Struct，Class的聲明方式幾乎和Struct如出一轍，也能夠在內部增長方法。從表看上看，只有初始化器又一些不一樣點。


類的初始化器

成員的初始化是在這個初始化器中完成的，如下是兩端徹底等效的代碼(證實方法同上---彙編)

class Point {
    var x: Int = 10
    var y: Int = 20
}
let p = Point()
複製代碼
class Point {
    var x: Int
    var y: Int
    init() {
        x = 10
        y = 20
    }
}
let p = Point()
複製代碼

結構體與類的本質區別

結構體是值類型（枚舉也是值類型），類是引用類型（指針類型）

class Size {
    var width = 1
    var height = 2
}

struct Point {
    var x = 3
    var y = 4
}

func test() {
    var size = Size()
    var point = Point()
}
複製代碼

上面代碼中的size和point在內存中的分佈狀況以下 image


對象的堆空間申請過程

先看下面的場景

func testClassAndStruct() {
    class Size {
        var width = 1
        var height = 2
    }

    struct Point {
        var x = 3
        var y = 4
    }

    var size = Size() //-----這裏加上斷點並運行，打開彙編界面
    //var point = Point()
}

testClassAndStruct()
複製代碼

image image image image image

在Swift中，建立類的實例對象，要向堆空間申請內存，大概流程以下

  • Class.__allocating_init()
  • libswiftCore.dylib:_swift_allocObject_
  • libswiftCore.dylib:swift_slowAlloc
  • libsystem_malloc.dylib:malloc

在Mac、iOS中的malloc函數分配的內存大小老是16的倍數 經過class_getInstanceSize能夠得知類的對象真正使用的內存大小

class Point {
    var x = 11
    var test = true
    var y = 22
}
var p = Point()
print(class_getInstanceSize(type(of: p)))  //40
print(class_getInstanceSize(Point.self))   //40
複製代碼

值類型

  • 值類型賦值給var、let或者給函數傳參，是直接將全部內容拷貝一份

相似於對文件進行copy、paste操做，產生了全新的文件副本。屬於深拷貝（deep copy） image


值類型的賦值操做

  • 在Swift標準庫中，爲了提高性能，String、Array、Dictionary、Set採起了Copy On Write的技術
    1. 好比僅當有「寫」操做時，纔會真正執行拷貝操做
    2. 對於標準庫值類型的賦值操做，Swift能確保最佳性能，因此沒有必要爲了保證最佳新能來避免賦值

須要注意的是，上面說的僅僅針對Swift標準庫，對於自定義的結構體來講，Swift不會使用Copy On Write技術

  • 建議：不須要修改的，儘可能定義成let
var s1 = "Jack"
var s2 = s1
s2.append("_Rose")
print(s1)//Jack
print(s2)//Jack_Rose

var a1 = [1,2,3]
var a2 = a1
a2.append(4)
a1[0] = 2
print(a1)//[1,3,4]
print(a2)//[1,2,3,4]

var d1 = ["max": 10, "min":2]
var d2 = d1
d1["other"] = 7
d2["max"] = 12
print(d1)//["other": 7, "max": 10, "min":2]
print(d2)//["max": 12, "min":2]
複製代碼

引用類型

  • 引用賦值給var、let或者給函數傳參，是將內存地址拷貝一份

相似於製做一個文件的替身（快捷方式，連接），指向的是同一個文件。屬於淺拷貝（shallow copy）

class Size {
    var width: Int
    var height: Int
    init(width: Int, height: Int) {
        self.width = width
        self.height = height
    }
}

func test() {
    var s1 = Size(width: 10, height: 20)
    var s2 = s1

    s2.width = 11
    s2.height = 22
}

test()
複製代碼

image


引用類型的賦值操做

class Size {
    var width: Int
    var height: Int
    init(width: Int, height: Int) {
        self.width = width
        self.height = height
    }
}

var s1 = Size(width: 10, height: 20)
s1 = Size(width: 11, height: 12)
複製代碼

image


值類型、引用類型的let

在這裏插入圖片描述

總結一下就是：let的含義就是其修飾的常量所對應的那段內存空間裏面的內容不能夠修改。

  • 值類型因爲全部的成員都在其內存裏面，所以被let修飾時候，其內部的成員都是不能夠修改的
  • 引用類型因爲它的內存裏存放的只是指針，因此只有這個指針的值不能修改，可是該指針所指向的堆空間的那個對象實例，並非引用類型內存裏面的東西，所以被let修飾以後，仍然能夠修改堆空間對象的成員的值。

嵌套類型

struct Poker {
    enum Suit: Character {
        case spades = "️", heart = "️", diamonds = "️", clubs = "️"
    }
    enum Rand: Int {
        case two = 2, three, four, five, six, seven, eight, nine, ten
        case jack, queen, king, ace
    }
}
print(Poker.Suit.heart.rawValue)

var suit = Poker.Suit.spades
suit = .diamonds

var rank = Poker.Rand.five
rank = .king
複製代碼

枚舉、結構體、類均可以定義方法

  • 通常把定義在枚舉、結構體、類內部的函數，叫作方法
class Size {
    var width = 10
    var height = 10
    func show() {
        print("width= \(width), height= \(height)")
    }
}
let s = Size()
s.show()

struct Point {
    var x = 10
    var y = 10
    func show() {
        print("x= \(x), y= \(y)")
    }
}
let p = Point()
p.show()

enum PokerFace: Character {
    case spades = "️", heart = "️", diamonds = "️", clubs = "️"
    func show() {
        print("face is \(rawValue)")
    }
}
let pf = PokerFace.heart
pf.show()
複製代碼
  • 方法佔用內存的對象嗎？
    1. 不佔用
    2. 方法的本質就是函數
    3. 方法、函數都放在代碼段
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程