Swift 分类 结构体

感谢原作者：http://www.cocoachina.com/newbie/basic/2014/0612/8780.html

类和结构体是人们构建代码所用的一种通用且灵活的构造体。为了在类和结构体中实现各种功能，我们必需要严格依照对于常量，变量以及函数所规定的语法规则来定义属性和加入方法。

与其他编程语言所不同的是。Swift 并不要求你为自己定义类和结构去创建独立的接口和实现文件。你所要做的是在一个单一文件里定义一个类或者结构体，系统将会自己主动生成面向其他代码的外部接口。

注意：通常一个类的实例被称为对象。然而在Swift 中，类和结构体的关系要比在其它语言中更加的密切。本章中所讨论的大部分功能都能够用在类和结构体上。因此，我们会主要使用实例而不是对象。

类和结构体对照

Swift 中类和结构体有非常多共同点。共同处在于：

定义属性用于储存值

定义方法用于提供功能

定义下标用于通过下标语法訪问值

定义初始化器用于生成初始化值

通过扩展以添加默认实现的功能

符合协议以对某类提供标准功能

很多其它信息请參见 属性，方法。下标，初始过程，扩展。和协议。

与结构体相比，类还有例如以下的附加功能：

继承同意一个类继承还有一个类的特征

类型转换同意在执行时检查和解释一个类实例的类型

取消初始化器同意一个类实例释放不论什么其所被分配的资源

引用计数同意对一个类的多次引用

很多其它信息请參见继承。类型转换，初始化，和自己主动引用计数。

注意：结构体总是通过被复制的方式在代码中传递。因此请不要使用引用计数。

定义

类和结构体有着类似的定义方式。我们通过keywordclass和struct来分别表示类和结构体，并在一对大括号里定义它们的详细内容：

class SomeClass {
// class definition goes here
}
struct SomeStructure {
// structure definition goes here
}

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

相反的，请使用lowerCamelCase这样的方式为属性和方法命名（如framerate和incrementCount），以便和类区分。

下面是定义结构体和定义类的演示样例：

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

}

在上面的演示样例中我们定义了一个名为Resolution的结构体，用来描写叙述一个显示器的像素分辨率。这个结构体包括了两个名为width和height的储存属性。储存属性是捆绑和储存在类或结构体中的常量或变量。当这两个属性被初始化为整数0的时候，它们会被判断为Int类型。

在上面的演示样例中我们还定义了一个名为VideoMode的类。用来描写叙述一个视频显示器的特定模式。这个类包括了四个储存属性变量。

第一个是分辨率，它被初始化为一个新的Resolution结构体的实例。具有Resolution的属性类型。

新VideoMode实例同一时候还会初始化其他三个属性，它们各自是，初始值为false(意为“non-interlaced video”)的inteflaced。回放帧率初始值为0.0的frameRate和值为可选String的name。name属性会被自己主动赋予一个默认值nil，意为“没有name值”。因它是一个可选类型。

类和结构体实例

Resolution结构体和VideoMode类的定义仅描写叙述了什么是Resolution和VideoMode。它们并没有描写叙述一个特定的分辨率（resolution）或者视频模式（video mode）。

为了描写叙述一个特定的分辨率或者视频模式，我们须要生成一个它们的实例。

生成结构体和类实例的语法很相似：

let someResolution = Resolution()
let someVideoMode = VideoMode()

结构体和类都使用初始化器语法来生成新的实例。

初始化器语法的最简单形式是在结构体或者类的类型名称后尾随一个空括弧，如Resolution()或VideoMode()。通过这样的方式所创建的类或者结构体实例，其属均会被初始化为默认值。构造过程章节会对类和结构体的初始化进行更具体的讨论。

属性訪问

通过使用点语法（dot syntax）,你能够訪问实例中所含有的属性。其语法规则是。实例名后面紧跟属性名，两者通过点号(.)连接：

println("The width of someResolution is \(someResolution.width)")
// 输出 "The width of someResolution is 0"

在上面的样例中。someResolution.width引用someResolution的width属性，返回width的初始值0。

你也能够訪问子属性，怎样VideoMode中Resolution属性的width属性：

println("The width of someVideoMode is \(someVideoMode.resolution.width)")
// 输出 "The width of someVideoMode is 0"

你也能够使用点语法为属性变量赋值：

someVideoMode.resolution.width = 12880
println("The width of someVideoMode is now \(someVideoMode.resolution.width)")
// 输出 "The width of someVideoMode is now 1280"

注意：与 Objective-C 语言不同的是，Swift 同意直接设置结构体属性的子属性。上面的最后一个样例，就是直接设置了someVideoMode中resolution属性的width这个子属性，以上操作并不须要从新设置resolution属性。

结构体类型的成员逐一初始化器

//Memberwise Initializers for structure Types

全部结构体都有一个自己主动生成的成员逐一初始化器，用于初始化新结构体实例中成员的属性。

新实例中各个属性的初始值能够通过属性的名称传递到成员逐一初始化器之中：

let vga = resolution（width:640, heigth: 480）

与结构体不同，类实例没有默认的成员逐一初始化器。

构造过程章节会对初始化器进行更具体的讨论。

结构体和枚举是值类型

值类型被赋予给一个变量，常数或者本身被传递给一个函数的时候，实际上操作的是其的拷贝。

在之前的章节中，我们已经大量使用了值类型。

实际上，在 Swift 中，全部的基本类型：整数(Integer)、浮点数(floating-point)、布尔值(Booleans)、字符串(string)、数组(array)和字典(dictionaries)。都是值类型。而且都是以结构体的形式在后台所实现。

在 Swift 中。全部的结构体和枚举都是值类型。这意味着它们的实例，以及实例中所包括的不论什么值类型属性，在代码中传递的时候都会被复制。

请看以下这个演示样例。其使用了前一个演示样例中Resolution结构体：

let hd = Resolution(width: 1920, height: 1080)
var cinema = hd

在以上演示样例中。声明了一个名为hd的常量。其值为一个初始化为全高清视频分辨率(1920 像素宽，1080 像素高)的Resolution实例。

然后演示样例中又声明了一个名为cinema的变量，其值为之前声明的hd。由于Resolution是一个结构体，所以cinema的值事实上是hd的一个拷贝副本。而不是hd本身。虽然hd和cinema有着同样的宽(width)和高(height)属性，可是在后台中。它们是两个全然不同的实例。

以下。为了符合数码影院放映的需求(2048 像素宽，1080 像素高)，cinema的width属性须要作例如以下改动：

cinema.width = 2048

这里。将会显示cinema的width属性确已改为了2048：

println("cinema is now  \(cinema.width) pixels wide")
// 输出 "cinema is now 2048 pixels wide"

然而，初始的hd实例中width属性还是1920：

println("hd is still \(hd.width ) pixels wide")
// 输出 "hd is still 1920 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 rememberDirection == .West {
println("The remembered direction is still .West")
}
// 输出 "The remembered direction is still .West"

上例中rememberedDirection被赋予了currentDirection的值(value)，实际上它被赋予的是值(value)的一个拷贝。赋值过程结束后再改动currentDirection的值并不影响rememberedDirection所储存的原始值(value)的拷贝。

类是引用类型

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

请看以下这个演示样例。其使用了之前定义的VideoMode类：

let tenEighty = VideoMode()
tenEighty.resolution = hd
tenEighty.interlaced = true
tenEighty.name = "1080i"
tenEighty.frameRate = 25.0

以上演示样例中，声明了一个名为tenEighty的常量。其引用了一个VideoMode类的新实例。在之前的演示样例中。这个视频模式(video mode)被赋予了HD分辨率(1920*1080)的一个拷贝(hd)。

同一时候设置为交错(interlaced),命名为“1080i”。最后。其帧率是25.0帧每秒。

然后，tenEighty 被赋予名为alsoTenEighty的新常量，同一时候对alsoTenEighty的帧率进行改动：

let alsoTenEighty = tenEighty
alsoTenEighty.frameRate = 30.0

由于类是引用类型。所以tenEight和alsoTenEight实际上引用的是同样的VideoMode实例。换句话说，它们仅仅是同一个实例的两种叫法。

以下，通过查看tenEighty的frameRate属性。我们会发现它正确的显示了基本VideoMode实例的新帧率，其值为30.0：

println("The frameRate property of tenEighty is now \(tenEighty.frameRate)")
// 输出 "The frameRate property of theEighty is now 30.0"

须要注意的是tenEighty和alsoTenEighty被声明为常量(constants)而不是变量。然而你依旧能够改变tenEighty.frameRate和alsoTenEighty.frameRate,由于这两个常量本身不会改变。它们并不储存这个VideoMode实例，在后台不过对VideoMode实例的引用。所以，改变的是被引用的基础VideoMode的frameRate參数。而不改变常量的值。

恒等运算符

由于类是引用类型，有可能有多个常量和变量在后台同一时候引用某一个类实例。

(对于结构体和枚举来说，这并不成立。由于它们作值类型。在被赋予到常量。变量或者传递到函数时，总是会被拷贝。

)

假设可以判定两个常量或者变量是否引用同一个类实例将会非常有帮助。为了达到这个目的，Swift 内建了两个恒等运算符：

等价于 ( === )

不等价于 ( !== )

下面是运用这两个运算符检測两个常量或者变量是否引用同一个实例：

if tenEighty === alsoTenTighty {
println("tenTighty and alsoTenEighty refer to the same Resolution instance.")
}
//输出 "tenEighty and alsoTenEighty refer to the same Resolution instance."

请注意“等价于”(用三个等号表示，===) 与“等于”(用两个等号表示，==)的不同：

“等价于”表示两个类类型(class type)的常量或者变量引用同一个类实例。

“等于”表示两个实例的值“相等”或“同样”，判定时要遵照类设计者定义定义的评判标准，因此相比于“相等”。这是一种更加合适的叫法。

当你在定义你的自己定义类和结构体的时候，你有义务来决定判定两个实例“相等”的标准。在章节运算符函数(Operator Functions)中将会具体介绍实现自己定义“等于”和“不等于”运算符的流程。

指针

假设你有 C，C++ 或者 Objective-C 语言的经验。那么你或许会知道这些语言使用指针来引用内存中的地址。一个 Swift 常量或者变量引用一个引用类型的实例与C语言中的指针类似。不同的是并不直接指向内存中的某个地址。并且也不要求你使用星号(*)来表明你在创建一个引用。Swift 中这些引用与其他的常量或变量的定义方式同样。

类和结构体的选择

在你的代码中，你能够使用类和结构体来定义你的自己定义数据类型。

然而，结构体实例总是通过值传递，类实例总是通过引用传递。这意味两者适用不同的任务。当你的在考虑一个project项目的数据构造和功能的时候，你须要决定每一个数据构造是定义成类还是结构体。

依照通用的准则。当符合一条或多条下面条件时。请考虑构建结构体：

结构体的主要目的是用来封装少量相关简单数据值。

有理由估计一个结构体实例在赋值或传递时。封装的数据将会被拷贝而不是被引用。

不论什么在结构体中储存的值类型属性，也将会被拷贝。而不是被引用。

结构体不须要去继承还有一个已存在类型的属性或者行为。

合适的结构体候选者包含：

几何形状的大小，封装一个width属性和height属性。两者均为Double类型。

一定范围内的路径。封装一个start属性和length属性，两者均为Int类型。

三维坐标系内一点，封装x。y和z属性。三者均为Double类型。

在全部其他案例中，定义一个类。生成一个它的实例，并通过引用来管理和传递。实际中，这意味着绝大部分的自己定义数据构造都应该是类，而非结构体。

集合(Collection)类型的赋值和拷贝行为

Swift 中数组(Array)和字典(Dictionary)类型均以结构体的形式实现。然而当数组被赋予一个常量或变量。或被传递给一个函数或方法时。其拷贝行为与字典和其他结构体有些许不同。

下面对数组和结构体的行为描写叙述与对NSArray和NSDictionary的行为描写叙述在本质上不同。后者是以类的形式实现，前者是以结构体的形式实现。NSArray和NSDictionary实例总是以对已有实例引用,而不是拷贝的方式被赋值和传递。

注意：下面是对于数组。字典。字符串和其他值的拷贝的描写叙述。 在你的代码中，拷贝好像是确实是在有拷贝行为的地方产生过。然而，在Swift 的后台中，仅仅有确有必要，实际(actual)拷贝才会被运行。

Swift 管理全部的值拷贝以确保性能最优化的性能。所以你也没有必要去避免赋值以保证最优性能。

(实际赋值由系统管理优化)

字典类型的赋值和拷贝行为

不管何时将一个字典实例赋给一个常量或变量。或者传递给一个函数或方法，这个字典会即会在赋值或调用发生时被拷贝。在章节结构体和枚举是值类型中将会对此过程进行具体介绍。

假设字典实例中所储存的键(keys)和/或值(values)是值类型(结构体或枚举)，当赋值或调用发生时，它们都会被拷贝。相反。假设键(keys)和/或值(values)是引用类型，被拷贝的将会是引用，而不是被它们引用的类实例或函数。

字典的键和值的拷贝行为与结构体所储存的属性的拷贝行为同样。

以下的演示样例定义了一个名为ages的字典，当中储存了四个人的名字和年龄。ages字典被赋予了一个名为copiedAges的新变量，同一时候ages在赋值的过程中被拷贝。

赋值结束后。ages和copiedAges成为两个相互独立的字典。

var ages = ["Peter": 23, "Wei": 35, "Anish": 65, "Katya": 19]
var copiedAges = ages

这个字典的键(keys)是字符串(String)类型。值(values)是整(Int)类型。

这两种类型在Swift 中都是值类型(value types)，所以当字典被拷贝时。两者都会被拷贝。

我们能够通过改变一个字典中的年龄值(age value)，检查还有一个字典中所相应的值，来证明ages字典确实是被拷贝了。假设在copiedAges字典中将Peter的值设为24。那么ages字典仍然会返回改动前的值23：

copiedAges["Peter"] = 24
println(ages["Peter"])
// 输出 "23"

数组的赋值和拷贝行为

在Swift 中。数组(Arrays)类型的赋值和拷贝行为要比字典(Dictionary)类型的复杂的多。当操作数组内容时。数组(Array)能提供接近C语言的的性能。而且拷贝行为仅仅有在必要时才会发生。

假设你将一个数组(Array)实例赋给一个变量或常量，或者将其作为參数传递给函数或方法调用。在事件发生时数组的内容不会被拷贝。相反，数组公用同样的元素序列。

当你在一个数组内改动某一元素。改动结果也会在还有一数组显示。

对数组来说，拷贝行为只当操作有可能改动数组长度时才会发生。

这样的行为包含了附加(appending),插入(inserting),删除(removing)或者使用范围下标(ranged subscript)去替换这一范围内的元素。唯独当数组拷贝确要发生时，数组内容的行为规则与字典中键值的同样，參见章节[集合（collection）类型的赋值与复制行为](#assignment_and_copy_behavior_for_collection_types。

以下的演示样例将一个整数(Int)数组赋给了一个名为a的变量，继而又被赋给了变量b和c：

var a = [1, 2, 3]
var b = a
var c = a

我们能够在a,b,c上使用下标语法以得到数组的第一个元素：

println(a[0])
// 1
println(b[0])
// 1
println(c[0])
// 1

假设通过下标语法改动数组中某一元素的值。那么a,b,c中的对应值都会发生改变。请注意当你用下标语法改动某一值时，并没有拷贝行为伴随发生，由于下表语法改动值时没有改变数组长度的可能：

a[0] = 42
println(a[0])
// 42
println(b[0])
// 42
println(c[0])
// 42

然而。当你给a附加新元素时。数组的长度会改变。

当附加元素这一事件发生时，Swift 会创建这个数组的一个拷贝。

从此以后，a将会是原数组的一个独立拷贝。

拷贝发生后，假设再改动a中元素值的话，a将会返回与b。c不同的结果。由于后两者引用的是原来的数组：

a.append(4)
a[0] = 777
println(a[0])
// 777
println(b[0])
// 42
println(c[0])
// 42

确保数组的唯一性

在操作一个数组，或将其传递给函数以及方法调用之前是非常有必要先确定这个数组是有一个唯一拷贝的。

通过在数组变量上调用unshare方法来确定数组引用的唯一性。

(当数组赋给常量时。不能调用unshare方法)

假设一个数组被多个变量引用，在当中的一个变量上调用unshare方法。则会拷贝此数组，此时这个变量将会有属于它自己的独立数组拷贝。当数组仅被一个变量引用时，则不会有拷贝发生。

在上一个演示样例的最后，b和c都引用了同一个数组。此时在b上调用unshare方法则会将b变成一个唯一个拷贝：

b.unshare()

在unshare方法调用后再改动b中第一个元素的值，这三个数组(a,b,c)会返回不同的三个值：

b[0] = -105
println(a[0])
// 77
println(b[0])
// -105
println(c[0])
// 42

判定两个数组是否共用同样元素

我们通过使用恒等运算符(identity operators)( === and !==)来判定两个数组或子数组共用同样的储存空间或元素。

以下这个演示样例使用了“恒等于(identical to)” 运算符(===) 来判定b和c是否共用同样的数组元素：

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.")
}

// 输出 "b and c now refer totwo independent sets of array elements."

此外，我们还能够使用恒等运算符来判定两个子数组是否共用同样的元素。以下这个演示样例中。比較了b的两个相等的子数组。而且确定了这两个子数组都引用同样的元素：

if b[0...1] === b[0...1] {
println("These two subarrays share the same elements.")
} else {
println("These two subarrays do not share the same elements.")
}
// 输出 "These two subarrays share the same elements."

强制复制数组

我们通过调用数组的copy方法进行强制显性复制。这种方法对数组进行了浅拷贝(shallow copy),而且返回一个包括此拷贝的新数组。

以下这个演示样例中定义了一个names数组，其包括了七个人名。

还定义了一个copiedNames变量，用以储存在names上调用copy方法所返回的结果：

var names = ["Mohsen", "Hilary", "Justyn", "Amy", "Rich", "Graham", "Vic"]
var copiedNames = names.copy

我们能够通过改动一个数组中某元素。而且检查还有一个数组中相应元素的方法来判定names数组确已被复制。假设你将copiedNames中第一个元素从"Mohsen"改动为"Mo",则names数组返回的仍是拷贝发生前的"Mohsen"：

copiedName[0] = "Mo"
println(name[0])
// 输出 "Mohsen"

注意：假设你仅须要确保你对数组的引用是唯一引用，请调用unshare方法，而不是copy方法。unshare方法仅会在确有必要时才会创建阵列复制。copy无论用什么方法将时间来创建一个新副本。即使参考已仅引。