{
//        結(jié)構(gòu)體
//        在 Swift 標(biāo)準(zhǔn)庫中，絕大多數(shù)的公開類型都是結(jié)構(gòu)體，而枚舉和類只占很小一部分 p比如Bool、Int、Double、 String、Array、Dictionary等常見類型都是結(jié)構(gòu)體
         struct Date {
            var year: Int
            var month: Int
            var day: Int
        }
         var date = Date(year: 2019, month: 6, day: 23)
        date = Date.init(year: 2011, month: 01, day: 12)
//        所有的結(jié)構(gòu)體都有一個(gè)編譯器自動(dòng)生成的初始化器(initializer，初始化方法、構(gòu)造器、構(gòu)造方法) 初始化調(diào)用的，可以傳入所有成員值，用以初始化所有成員(存儲(chǔ)屬性，Stored Property)
        
//        結(jié)構(gòu)體的初始化器
//        編譯器會(huì)根據(jù)情況，可能會(huì)為結(jié)構(gòu)體生成多個(gè)初始化器，宗旨是:保證所有成員都有初始值
        struct Point {
            var x : Int = 0
            var y : Int = 0
        }
        
        _ = Point(x: 1, y: 2)
        _ = Point(x : 1)
        _ = Point(y : 1)
        _ = Point()
        
        // 如果是可選值 可以不寫
        struct Point2 {
            var x : Int?
            var y : Int?
        }
        
        _ = Point2(x: 1, y: 2)
        _ = Point2(x : 1)
        _ = Point2(y : 1)
        _ = Point2()
        
//        自定義初始化器
//        n 一旦在定義結(jié)構(gòu)體時(shí)自定義了初始化器，編譯器就不會(huì)再幫它自動(dòng)生成其他初始化器
        struct Point3 {
            var a : Int = 0
            var b : Int = 0
            init(x : Int, y : Int) {
                self.a = x
                b = y
            }
            
            init() {
                a = 0
                b = 0
            }
        }
        
        _ = Point3(x: 1, y: 2)
//        _ = Point3(x : 1)// 報(bào)錯(cuò)
//        _ = Point3(y : 1)// 報(bào)錯(cuò)
        _ = Point3()
        
//        結(jié)構(gòu)體內(nèi)存結(jié)構(gòu)
         struct Point4 {
            var x: Int = 0
            var y: Int = 0
            var origin: Bool = false
        }
        print(MemoryLayout<Point>.size) // 17
        print(MemoryLayout<Point>.stride) // 24
        print(MemoryLayout<Point>.alignment) // 8
        
//        類
        func ppf_class() {
//            類的定義和結(jié)構(gòu)體類似，但編譯器并沒有為類自動(dòng)生成可以傳入成員值的初始化器
              class Point {
                var x: Int
                var y: Int
                
                init(x : Int,y : Int) {
                    self.x = x
                    self.y = y
                }
              }
            let p2 = Point(x: 10, y: 20)
        }
        
        ppf_class()
        
        func ppf_class2() {
//            類的初始化器
//            n 如果類的所有成員都在定義的時(shí)候指定了初始值，編譯器會(huì)為類生成無參的初始化器 p成員的初始化是在這個(gè)初始化器中完成的
              class Point {
                var x: Int = 10
                var y: Int = 20
            }
            let p = Point()

            class Point1 {
                var x: Int
                var y: Int
                
                init() {
                    x = 10
                    y = 20
                }
            }
            let p1 = Point1()
            //            n 上面2段代碼是完全等效的
        }
        
        ppf_class2()
        
        func ppf_class3() {
//            結(jié)構(gòu)體與類的本質(zhì)區(qū)別
//            結(jié)構(gòu)體是值類型(枚舉也是值類型)，類是引用類型(指針類型)
               class Size {
                var width = 1
                var height = 2
            }

            struct Point {
                var x = 3
                var y = 4
            }
            func test() {
                var size = Size()
                var point = Point()
            }
        }
        
        ppf_class3()
        
        
        func ppf_class4() {
//            值類型
//            值類型賦值給var、let或者給函數(shù)傳參，是直接將所有內(nèi)容拷貝一份
//            類似于對(duì)文件進(jìn)行copy、paste操作，產(chǎn)生了全新的文件副本。屬于深拷貝(deep copy)
            
//            值類型的賦值操作
            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) // [2, 2, 3]
            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]
//            在Swift標(biāo)準(zhǔn)庫中，為了提升性能，String、Array、Dictionary、Set采取了Copy On Write的技術(shù)
//            比如僅當(dāng)有“寫”操作時(shí)，才會(huì)真正執(zhí)行拷貝操作
//            對(duì)于標(biāo)準(zhǔn)庫值類型的賦值操作，Swift 能確保最佳性能，所有沒必要為了保證最佳性能來避免賦值
//            建議:不需要修改的，盡量定義成let
        }
        
        ppf_class4()
        
        
        func ppf_class5() {
//            引用類型
//            引用賦值給var、let或者給函數(shù)傳參，是將內(nèi)存地址拷貝一份 p類似于制作一個(gè)文件的替身(快捷方式、鏈接)，指向的是同一個(gè)文件。屬于淺拷貝(shallow copy)
            class Size {
                var width: Int
                var height: Int
                init(width: Int, height: Int) {
                    self.width = width
                    self.height = height
                }
            }
            
            func test() {
                let s1 = Size(width: 10, height: 20)
                let s2 = s1
                s2.width = 11
                s2.height = 22
            }
        }
        
        ppf_class5()
        
        func ppf_class6() {
//            對(duì)象的堆空間申請(qǐng)過程
//            在Swift中，創(chuàng)建類的實(shí)例對(duì)象，要向堆空間申請(qǐng)內(nèi)存，大概流程如下
//            pClass.__allocating_init()
//            plibswiftCore.dylib : _swift_allocObject_
//            plibswiftCore.dylib : swift_slowAlloc
//            plibsystem_malloc.dylib : malloc
//            在Mac、iOS中的malloc函數(shù)分配的內(nèi)存大小總是16的倍數(shù)
//            通過class_getInstanceSize可以得知:類的對(duì)象至少需要占用多少內(nèi)存
             class Point  {
                var x = 11
                var test = true
                var y = 22
             }
            
            let p = Point()
            print(class_getInstanceSize(type(of: p))) // 40
            print(class_getInstanceSize(Point.self)) // 40
    
        }
        
        ppf_class6()
        
        
        func ppf_class7() {
//            嵌套類型
             struct Poker {
                enum Suit : Character {
                    case spades = "?", hearts = "?" , clubs = "?", diamonds = "?"
                }
                
                enum Rank : Int {
                    case two = 2, three, four, five, six, seven, eight, nine, ten
                    case jack, queen, king, ace
                }
            }
             print(Poker.Suit.hearts.rawValue)
            var suit = Poker.Suit.spades
            suit = .diamonds
            var rank = Poker.Rank.five
            rank = .king
        }
        
        ppf_class7()
        
        
        func ppf_class8() {
//            枚舉、結(jié)構(gòu)體、類都可以定義方法
//            n 一般把定義在枚舉、結(jié)構(gòu)體、類內(nèi)部的函數(shù)，叫做方法
            class Size {
                var width = 10
                var height = 10
                func show() {
                print("width=\(width), height=\(height)") }
            }
            
            let s = Size()
            s.show() // width=10, height=10
            
            
            struct Point {
                var x = 10
                var y = 10
                func show() { print("x=\(x), y=\(y)")
            
                }
            }
            
            let p = Point()
            p.show() // x=10, y=10
            
            enum PokerFace : Character {
                case spades = "?", hearts = "?", diamonds = "?" ,clubs =  "?"
                func show() {
                    print("face is \(rawValue)")
                }
           }
            
            let pf = PokerFace.hearts
            pf.show() // face is ?
           
//             方法占用對(duì)象的內(nèi)存么? 不占用 方法的本質(zhì)就是函數(shù) 方法、函數(shù)都存放在代碼段
        }
        
        
        
        ppf_class8()
        

    }