Swift --- 2.9类和结构体

struct Resolution {
    var width = 0
    var height = 0
}

class VideoMode {
    var resolution = Resolution()
    var interlaced = false
    var frameRate = 0.0
    var name: String?
}

class ViewController: UIViewController {
                            
    override func viewDidLoad() {
        super.viewDidLoad()
        
        let someResolution = Resolution()
        let someVideoMode = VideoMode()
        
        let vga = Resolution(width:640, height: 480)
        println(vga.width)
        someVideoMode.resolution.height = 100
        println(someVideoMode.resolution.height)

        
        //结构体和枚举是值类型 实现深拷贝
        let hd = Resolution(width: 1920, height: 1080)
        var cinema = hd
        
        cinema.width = 2048
        println(hd.width)
        println(cinema.width)
        
        //类是引用类型 实现浅拷贝,指针拷贝
        let tenEighty = VideoMode()
        tenEighty.resolution = hd
        tenEighty.interlaced = true
        tenEighty.name = "1080i"
        tenEighty.frameRate = 25.0
        
        let alsoTenEighty = tenEighty
        alsoTenEighty.frameRate = 30.0
        
        println(alsoTenEighty.frameRate)
        println(tenEighty.frameRate)
        
        //结构体不能用 恒等运算符
//        if cinema === hd {
//            println("same")
//        }else{
//            println("error")
//        }
        
        //类可以用恒等运算符
        if alsoTenEighty === tenEighty {
            println("same")
        }else{
            println("error")
        }
        
        /**
            类和结构体的选择
        
        在你的代码中，你可以使用类和结构体来定义你的自定义数据类型。
        
        然而，结构体实例总是通过值传递，类实例总是通过引用传递。这意味两者适用不同的任务。当你的在考虑一个工程项目的数据构造和功能的时候，你需要决定每个数据构造是定义成类还是结构体。
        
        按照通用的准则，当符合一条或多条以下条件时，请考虑构建结构体：
        
        结构体的主要目的是用来封装少量相关简单数据值。
        有理由预计一个结构体实例在赋值或传递时，封装的数据将会被拷贝而不是被引用。
        任何在结构体中储存的值类型属性，也将会被拷贝，而不是被引用。
        结构体不需要去继承另一个已存在类型的属性或者行为。
        合适的结构体候选者包括：
        
        几何形状的大小，封装一个width属性和height属性，两者均为Double类型。
        一定范围内的路径，封装一个start属性和length属性，两者均为Int类型。
        三维坐标系内一点，封装x，y和z属性，三者均为Double类型。
        在所有其它案例中，定义一个类，生成一个它的实例，并通过引用来管理和传递。实际中，这意味着绝大部分的自定义数据构造都应该是类，而非结构体。
        */
    }

集合（Collection）类型的赋值和拷贝行为

//无论何时将一个字典实例赋给一个常量或变量，或者传递给一个函数或方法，这个字典会即会在赋值或调用发生时被拷贝。
        //如果字典实例中所储存的键（keys）和/或值（values）是值类型（结构体或枚举），当赋值或调用发生时，它们都会被拷贝。相反，如果键（keys）和/或值（values）是引用类型，被拷贝的将会是引用，而不是被它们引用的类实例或函数。字典的键和值的拷贝行为与结构体所储存的属性的拷贝行为相同。
        
        var ages = ["Peter": 23, "Wei": 35, "Anish": 65, "Katya": 19]
        var copiedAges = ages
        
        copiedAges["Peter"] = 24
        println(ages["Peter"])
        // 输出 "23"
        
        
        //如果你将一个数组（Array）实例赋给一个变量或常量，或者将其作为参数传递给函数或方法调用，在事件发生时数组的内容不会被拷贝。相反，数组公用相同的元素序列。当你在一个数组内修改某一元素，修改结果也会在另一数组显示。
        
        //对数组来说，拷贝行为仅仅当操作有可能修改数组长度时才会发生。这种行为包括了附加（appending）,插入（inserting）,删除（removing）或者使用范围下标（ranged subscript）去替换这一范围内的元素。
        
        var a = [42, 2, 3]
        var b = a
        var c = a
        
        a.append(4)
        a[0] = 777
        println(a[0])
        // 777
        println(b[0])
        // 42
        println(c[0])
        // 42
        
        b.unshare()
        b[0] = -105
        println(a[0])
        // 77
        println(b[0])
        // -105
        println(c[0])
        // 42
        
        //可以用恒等来进行判断
        if b === c {
            println("b and c still share the same array elements.")
        } else {
            println("b and c now refer to two independent sets of array elements.")
        }
        
        //可以用copy的方法进行深拷贝
        var names = ["Mohsen", "Hilary", "Justyn", "Amy", "Rich", "Graham", "Vic"]
        var copiedNames = names.copy()