Swift-类和结构体

//: Playground - noun: a place where people can play

import UIKit

var str = "Hello, playground"


//与其他编程语言所不同的是，Swift 并不要求你为自定义类和结构去创建独立的接口和实现文件。你所要做的是在一个单一文件中定义一个类或者结构体，系统将会自动生成面向其它代码的外部接口
/*
 注意： 通常一个类的实例被称为对象。然而在Swift 中，类和结构体的关系要比在其他语言中更加的密切，本章中所讨论的大部分功能都可以用在类和结构体上。因此，我们会主要使用实例而不是对象。
 */

//类和结构体对比
/*
 Swift 中类和结构体有很多共同点。共同处在于：
 
 定义属性用于存储值
 定义方法用于提供功能
 定义附属脚本用于访问值
 定义构造器用于生成初始化值
 通过扩展以增加默认实现的功能
 实现协议以提供某种标准功能
 更多信息请参见 属性，方法，下标脚本，初始过程，扩展，和协议。
 
 与结构体相比，类还有如下的附加功能：
 
 继承允许一个类继承另一个类的特征
 类型转换允许在运行时检查和解释一个类实例的类型
 解构器允许一个类实例释放任何其所被分配的资源
 引用计数允许对一个类的多次引用
 更多信息请参见继承，类型转换，析构过程，和自动引用计数。
 
 注意： 结构体总是通过被复制的方式在代码中传递，因此请不要使用引用计数。

 */

//通过关键字class和struct来分别表示类和结构体，并在一对大括号中定义它们的具体内容：
class SomeClass{
    func prinftFucn(){
        print("这是一个类");
    }
}

//SomeClass.init().prinftFucn() ;

SomeClass().prinftFucn()

struct SomeStructure {
    
    func prinftFucn()
    {
        print("这是一个结构体") ;
    }
}

//SomeStructure.init().prinftFucn()
SomeStructure().prinftFucn();

/*
 
 注意： 在你每次定义一个新类或者结构体的时候，实际上你是有效地定义了一个新的 Swift 类型。因此请使用 UpperCamelCase 这种方式来命名（如 SomeClass 和SomeStructure等），以便符合标准Swift 类型的大写命名风格（如String，Int和Bool）。相反的，请使用lowerCamelCase这种方式为属性和方法命名（如framerate和incrementCount），以便和类区分。
 */

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

//类和结构体实例
let someResolution = Resolution()
let someVideoMode = VideoMode()

//属性访问
/*
 通过使用点语法（dot syntax），你可以访问实例中所含有的属性。其语法规则是，实例名后面紧跟属性名，两者通过点号(.)连接：
 */
print("The width of someResolution is \(someResolution.width)")
print("The width of someVideoMode is \(someVideoMode.resolution.width)")

//可以使用点语法为属性变量赋值：
/*
 注意： 与 Objective-C 语言不同的是，Swift 允许直接设置结构体属性的子属性。上面的最后一个例子，就是直接设置了someVideoMode中resolution属性的width这个子属性，以上操作并不需要重新设置resolution属性。
 */

someVideoMode.resolution.width = 1280 ;
print("The width of someVideoMode is now \(someVideoMode.resolution.width)") ;

//结构体类型的成员逐一构造器 所有结构体都有一个自动生成的成员逐一构造器，用于初始化新结构体实例中成员的属性。新实例中各个属性的初始值可以通过属性的名称传递到成员逐一构造器之中：
//与结构体不同，类实例没有默认的成员逐一构造器
let vga = Resolution(width: 640, height: 480);

//结构体和枚举是值类型
//在 Swift 中，所有的结构体和枚举类型都是值类型。这意味着它们的实例，以及实例中所包含的任何值类型属性，在代码中传递的时候都会被复制。
let hd = Resolution(width: 1920, height: 1080)
var cinema = hd

//声明了一个名为cinema的变量，其值为之前声明的hd。因为Resolution是一个结构体，所以cinema的值其实是hd的一个拷贝副本，而不是hd本身。尽管hd和cinema有着相同的宽（width）和高（height）属性，但是在后台中，它们是两个完全不同的实例。
//cinema的width属性需要作如下修改：
cinema.width = 2048
print("cinema is now  \(cinema.width) pixels wide")

//初始的hd实例中width属性还是1920
print("hd is still \(hd.width    ) pixels wide")

//在将hd赋予给cinema的时候，实际上是将hd中所存储的值（values）进行拷贝，然后将拷贝的数据存储到新的cinema实例中。结果就是两个完全独立的实例碰巧包含有相同的数值。由于两者相互独立，因此将cinema的width修改为2048并不会影响hd中的width的值。


//枚举也遵循相同的行为准则：
enum CompassPoint {
    case North, South, East, West
}
var currentDirection = CompassPoint.West
let rememberedDirection = currentDirection
currentDirection = .East
if rememberedDirection == .West {
    print("The remembered direction is still .West")

}


//类是引用类型
//与值类型不同，引用类型在被赋予到一个变量、常量或者被传递到一个函数时，操作的是引用，其并不是拷贝。因此，引用的是已存在的实例本身而不是其拷贝

//声明了一个名为tenEighty的常量，其引用了一个VideoMode类的新实例。在之前的示例中，这个视频模式（video mode）被赋予了HD分辨率（1920*1080）的一个拷贝（hd）。同时设置为交错（interlaced）,命名为“1080i”。最后，其帧率是25.0帧每秒。
let tenEighty = VideoMode();
tenEighty.resolution = hd ;
tenEighty.interlaced = true ;
tenEighty.name = "1080i" ;
tenEighty.frameRate = 25.0 ;

//tenEighty 被赋予名为alsoTenEighty的新常量，同时对alsoTenEighty的帧率进行修改：
let alsoTenEighty = tenEighty ;
alsoTenEighty.frameRate = 30.0

//因为类是引用类型，所以tenEight和alsoTenEight实际上引用的是相同的VideoMode实例。换句话说，它们是同一个实例的两种叫法。
print("The frameRate property of tenEighty is now \(tenEighty.frameRate)")
/*
 注意的是tenEighty和alsoTenEighty被声明为常量（（constants）而不是变量。然而你依然可以改变tenEighty.frameRate和alsoTenEighty.frameRate,因为这两个常量本身不会改变。它们并不存储这个VideoMode实例，在后台仅仅是对VideoMode实例的引用。所以，改变的是被引用的基础VideoMode的frameRate参数，而不改变常量的值。
 */



//恒等运算符
/*
 因为类是引用类型，有可能有多个常量和变量在后台同时引用某一个类实例。（对于结构体和枚举来说，这并不成立。因为它们作为值类型，在被赋予到常量、变量或者传递到函数时，其值总是会被拷贝。）
 
 如果能够判定两个常量或者变量是否引用同一个类实例将会很有帮助。为了达到这个目的，Swift 内建了两个恒等运算符：
 
 等价于 （ === ）
 不等价于 （ !== ）
 以下是运用这两个运算符检测两个常量或者变量是否引用同一个实例：
 */
if tenEighty === alsoTenEighty {
    
    print("tenEighty 等价于 alsoTenEighty")
}

/*
 请注意“等价于"（用三个等号表示，===） 与“等于"（用两个等号表示，==）的不同：
 
 “等价于”表示两个类类型（class type）的常量或者变量引用同一个类实例。
 “等于”表示两个实例的值“相等”或“相同”，判定时要遵照类设计者定义定义的评判标准，因此相比于“相等”，这是一种更加合适的叫法。
 当你在定义你的自定义类和结构体的时候，你有义务来决定判定两个实例“相等”的标准。在章节等价操作符中将会详细介绍实现自定义“等于”和“不等于”运算符的流程。
 */



/********************   指针      ******/


//类和结构体的选择
/*
 在你的代码中，你可以使用类和结构体来定义你的自定义数据类型。
 
 然而，结构体实例总是通过值传递，类实例总是通过引用传递。这意味两者适用不同的任务。当你在考虑一个工程项目的数据构造和功能的时候，你需要决定每个数据构造是定义成类还是结构体。
 
 按照通用的准则，当符合一条或多条以下条件时，请考虑构建结构体：
 
 结构体的主要目的是用来封装少量相关简单数据值。
 有理由预计一个结构体实例在赋值或传递时，封装的数据将会被拷贝而不是被引用。
 任何在结构体中储存的值类型属性，也将会被拷贝，而不是被引用。
 结构体不需要去继承另一个已存在类型的属性或者行为。
 举例来说，以下情境中适合使用结构体：
 
 几何形状的大小，封装一个width属性和height属性，两者均为Double类型。
 一定范围内的路径，封装一个start属性和length属性，两者均为Int类型。
 三维坐标系内一点，封装x，y和z属性，三者均为Double类型。
 在所有其它案例中，定义一个类，生成一个它的实例，并通过引用来管理和传递。实际中，这意味着绝大部分的自定义数据构造都应该是类，而非结构体。
 */



//字符串(String)、数组(Array)、和字典(Dictionary)类型的赋值与复制行为

/*
 Swift 中字符串（String）,数组（Array）和字典（Dictionary）类型均以结构体的形式实现。这意味着String，Array，Dictionary类型数据被赋值给新的常量或变量，或者被传入函数或方法中时，它们的值会发生拷贝行为（值传递方式）。
 
 Objective-C中字符串（NSString）,数组（NSArray）和字典（NSDictionary）类型均以类的形式实现，这与Swfit中以值传递方式是不同的。NSString，NSArray，NSDictionary在发生赋值或者传入函数（或方法）时，不会发生值拷贝，而是传递已存在实例的引用。
 
 注意： 以上是对于字符串、数组、字典和其它值的拷贝的描述。 在你的代码中，拷贝好像是确实是在有拷贝行为的地方产生过。然而，在 Swift 的后台中，只有确有必要，实际（actual）拷贝才会被执行。Swift 管理所有的值拷贝以确保性能最优化的性能，所以你也没有必要去避免赋值以保证最优性能。（实际赋值由系统管理优化）
 */