玩Swift，来自Java背景，为什么要选择Struct而不是Class?看起来它们是一样的东西，只不过Struct提供的功能更少。那为什么选择它呢?
当前回答
这个答案最初是关于结构和类之间性能的差异。不幸的是，关于我使用的测量方法有太多的争议。我把它留在下面，但请不要过多地去理解它。我认为经过这么多年，在Swift社区中，struct(以及enum)由于其简单和安全而一直是首选。
如果性能对你的应用很重要，那就自己衡量。我仍然认为大多数时候结构性能更优越，但最好的答案就像有人在评论中说的那样:这要看情况。
===旧答案===
由于结构实例是在堆栈上分配的，而类实例是在堆上分配的，因此结构有时会快得多。
但是，您应该始终自己衡量它，并根据您独特的用例进行决定。
考虑下面的例子，它演示了使用结构和类包装Int数据类型的两种策略。我使用10个重复值是为了更好地反映现实世界，其中有多个字段。
class Int10Class {
let value1, value2, value3, value4, value5, value6, value7, value8, value9, value10: Int
init(_ val: Int) {
self.value1 = val
self.value2 = val
self.value3 = val
self.value4 = val
self.value5 = val
self.value6 = val
self.value7 = val
self.value8 = val
self.value9 = val
self.value10 = val
}
}
struct Int10Struct {
let value1, value2, value3, value4, value5, value6, value7, value8, value9, value10: Int
init(_ val: Int) {
self.value1 = val
self.value2 = val
self.value3 = val
self.value4 = val
self.value5 = val
self.value6 = val
self.value7 = val
self.value8 = val
self.value9 = val
self.value10 = val
}
}
func + (x: Int10Class, y: Int10Class) -> Int10Class {
return IntClass(x.value + y.value)
}
func + (x: Int10Struct, y: Int10Struct) -> Int10Struct {
return IntStruct(x.value + y.value)
}
使用以下方法来衡量性能
// Measure Int10Class
measure("class (10 fields)") {
var x = Int10Class(0)
for _ in 1...10000000 {
x = x + Int10Class(1)
}
}
// Measure Int10Struct
measure("struct (10 fields)") {
var y = Int10Struct(0)
for _ in 1...10000000 {
y = y + Int10Struct(1)
}
}
func measure(name: String, @noescape block: () -> ()) {
let t0 = CACurrentMediaTime()
block()
let dt = CACurrentMediaTime() - t0
print("\(name) -> \(dt)")
}
代码可以在https://github.com/knguyen2708/StructVsClassPerformance上找到
更新（2018年3月27日）：
Swift 4.0, Xcode 9.2，在iPhone 6S, iOS 11.2.6上运行Release build, Swift编译器设置为-O -全模块优化:
类版本用时2.06秒 Struct版本耗时4.17e-08秒(快了50,000,000倍)
(我不再平均多次运行，因为方差非常小，低于5%)
注意:在没有整个模块优化的情况下，差异会小很多。如果有人能指出这面旗子到底是干什么的，我会很高兴。
更新(2016年5月7日):
Swift 2.2.1, Xcode 7.3，在iPhone 6S, iOS 9.3.1上运行Release build，平均运行5次，Swift编译器设置为-O -whole-module-optimization:
类版本花费了2.159942142s struct版本耗时5.83 e -08秒(快37,000,000倍)
注意:正如有人提到的，在现实场景中，一个结构中可能会有多个字段，我已经为结构/类添加了10个字段而不是1个字段的测试。令人惊讶的是，结果变化不大。
原始结果(2014年6月1日):
(在struct/class上运行，只有1个字段，而不是10个)
在Swift 1.2、Xcode 6.3.2、iPhone 5S和iOS 8.3上运行Release版本时，平均运行超过5次
类版本花费了9.788332333s Struct版本花费0.010532942秒(快900倍)
旧结果(未知时间)
(在struct/class上运行，只有1个字段，而不是10个)
在我的MacBook Pro上发布:
类版本花费了1.10082秒 struct版本花了0.02324秒(快了50倍)
其他回答
以下是一些值得考虑的其他原因:
struct有一个自动初始化式，你根本不需要在代码中维护它。 struct MorphProperty { var类型:MorphPropertyValueType var键:字符串 var值:AnyObject enum MorphPropertyValueType { case字符串，Int, Double ｝ ｝ var m = MorphProperty(类型:.Int，键:“什么”，值:“blah”)
要在类中得到这个，你必须添加初始化式，并维护初始化式…
Basic collection types like Array are structs. The more you use them in your own code, the more you will get used to passing by value as opposed to reference. For instance: func removeLast(var array:[String]) { array.removeLast() println(array) // [one, two] } var someArray = ["one", "two", "three"] removeLast(someArray) println(someArray) // [one, two, three] Apparently immutability vs. mutability is a huge topic, but a lot of smart folks think immutability -- structs in this case -- is preferable. Mutable vs immutable objects
这个答案最初是关于结构和类之间性能的差异。不幸的是，关于我使用的测量方法有太多的争议。我把它留在下面，但请不要过多地去理解它。我认为经过这么多年，在Swift社区中，struct(以及enum)由于其简单和安全而一直是首选。
如果性能对你的应用很重要，那就自己衡量。我仍然认为大多数时候结构性能更优越，但最好的答案就像有人在评论中说的那样:这要看情况。
===旧答案===
由于结构实例是在堆栈上分配的，而类实例是在堆上分配的，因此结构有时会快得多。
但是，您应该始终自己衡量它，并根据您独特的用例进行决定。
考虑下面的例子，它演示了使用结构和类包装Int数据类型的两种策略。我使用10个重复值是为了更好地反映现实世界，其中有多个字段。
class Int10Class {
let value1, value2, value3, value4, value5, value6, value7, value8, value9, value10: Int
init(_ val: Int) {
self.value1 = val
self.value2 = val
self.value3 = val
self.value4 = val
self.value5 = val
self.value6 = val
self.value7 = val
self.value8 = val
self.value9 = val
self.value10 = val
}
}
struct Int10Struct {
let value1, value2, value3, value4, value5, value6, value7, value8, value9, value10: Int
init(_ val: Int) {
self.value1 = val
self.value2 = val
self.value3 = val
self.value4 = val
self.value5 = val
self.value6 = val
self.value7 = val
self.value8 = val
self.value9 = val
self.value10 = val
}
}
func + (x: Int10Class, y: Int10Class) -> Int10Class {
return IntClass(x.value + y.value)
}
func + (x: Int10Struct, y: Int10Struct) -> Int10Struct {
return IntStruct(x.value + y.value)
}
使用以下方法来衡量性能
// Measure Int10Class
measure("class (10 fields)") {
var x = Int10Class(0)
for _ in 1...10000000 {
x = x + Int10Class(1)
}
}
// Measure Int10Struct
measure("struct (10 fields)") {
var y = Int10Struct(0)
for _ in 1...10000000 {
y = y + Int10Struct(1)
}
}
func measure(name: String, @noescape block: () -> ()) {
let t0 = CACurrentMediaTime()
block()
let dt = CACurrentMediaTime() - t0
print("\(name) -> \(dt)")
}
代码可以在https://github.com/knguyen2708/StructVsClassPerformance上找到
更新（2018年3月27日）：
Swift 4.0, Xcode 9.2，在iPhone 6S, iOS 11.2.6上运行Release build, Swift编译器设置为-O -全模块优化:
类版本用时2.06秒 Struct版本耗时4.17e-08秒(快了50,000,000倍)
(我不再平均多次运行，因为方差非常小，低于5%)
注意:在没有整个模块优化的情况下，差异会小很多。如果有人能指出这面旗子到底是干什么的，我会很高兴。
更新(2016年5月7日):
Swift 2.2.1, Xcode 7.3，在iPhone 6S, iOS 9.3.1上运行Release build，平均运行5次，Swift编译器设置为-O -whole-module-optimization:
类版本花费了2.159942142s struct版本耗时5.83 e -08秒(快37,000,000倍)
注意:正如有人提到的，在现实场景中，一个结构中可能会有多个字段，我已经为结构/类添加了10个字段而不是1个字段的测试。令人惊讶的是，结果变化不大。
原始结果(2014年6月1日):
(在struct/class上运行，只有1个字段，而不是10个)
在Swift 1.2、Xcode 6.3.2、iPhone 5S和iOS 8.3上运行Release版本时，平均运行超过5次
类版本花费了9.788332333s Struct版本花费0.010532942秒(快900倍)
旧结果(未知时间)
(在struct/class上运行，只有1个字段，而不是10个)
在我的MacBook Pro上发布:
类版本花费了1.10082秒 struct版本花了0.02324秒(快了50倍)
结构和类之间的相似之处。
我用简单的例子来创建主旨。 https://github.com/objc-swift/swift-classes-vs-structures
和差异
1. 继承。
结构不能在swift中继承。如果你愿意
class Vehicle{
}
class Car : Vehicle{
}
参加一个培训班。
2. 经过
Swift结构按值传递，类实例按引用传递。
语境的差异
结构常量和变量
示例(用于2014年全球开发者大会)
struct Point{
var x = 0.0;
var y = 0.0;
}
定义一个名为Point的结构体。
var point = Point(x:0.0,y:2.0)
现在如果我试着改变x，它是一个有效的表达式。
point.x = 5
但如果我定义一个点为常数。
let point = Point(x:0.0,y:2.0)
point.x = 5 //This will give compile time error.
在这种情况下，整个点是不可变常数。
如果我使用类Point代替，这是一个有效的表达式。因为在一个类中，不可变常量是对类本身的引用，而不是它的实例变量(除非那些变量定义为常量)
在Swift中，引入了一种新的编程模式，称为面向协议编程。
创建型模式:
在swift中，Struct是一种自动克隆的值类型。因此，我们可以免费获得实现原型模式所需的行为。
而类是引用类型，在赋值过程中不会自动克隆。为了实现原型模式，类必须采用NSCopying协议。
浅拷贝只复制指向那些对象的引用，而深拷贝复制对象的引用。
为每种引用类型实现深度复制已成为一项乏味的任务。如果类包含进一步的引用类型，我们必须为每个引用属性实现原型模式。然后我们需要通过实现NSCopying协议复制整个对象图。
class Contact{
var firstName:String
var lastName:String
var workAddress:Address // Reference type
}
class Address{
var street:String
...
}
通过使用结构体和枚举，我们使我们的代码更简单，因为我们不需要实现复制逻辑。
结构vs类
[堆栈vs堆] [值vs参考类型]
结构更可取。但是缺省情况下，Struct并不能解决所有问题。通常你会听说值类型是在堆栈上分配的，但这并不总是正确的。只有局部变量被分配到堆栈上
//simple blocks
struct ValueType {}
class ReferenceType {}
struct StructWithRef {
let ref1 = ReferenceType()
}
class ClassWithRef {
let ref1 = ReferenceType()
}
func foo() {
//simple blocks
let valueType1 = ValueType()
let refType1 = ReferenceType()
//RetainCount
//StructWithRef
let structWithRef1 = StructWithRef()
let structWithRef1Copy = structWithRef1
print("original:", CFGetRetainCount(structWithRef1 as CFTypeRef)) //1
print("ref1:", CFGetRetainCount(structWithRef1.ref1)) //2 (originally 3)
//ClassWithRef
let classWithRef1 = ClassWithRef()
let classWithRef1Copy = classWithRef1
print("original:", CFGetRetainCount(classWithRef1)) //2 (originally 3)
print("ref1:", CFGetRetainCount(classWithRef1.ref1)) //1 (originally 2)
}
*你不应该使用/依赖retainCount，因为它没有提供有用的信息
检查堆栈或堆
在编译过程中SIL(Swift中间语言)可以优化你的代码
swiftc -emit-silgen -<optimization> <file_name>.swift
//e.g.
swiftc -emit-silgen -Onone file.swift
//emit-silgen -> emit-sil(is used in any case)
//-emit-silgen Emit raw SIL file(s)
//-emit-sil Emit canonical SIL file(s)
//optimization: O, Osize, Onone. It is the same as Swift Compiler - Code Generation -> Optimization Level
在那里你可以找到alloc_stack(在堆栈上的分配)和alloc_box(在堆上的分配)
(优化级别(SWIFT_OPTIMIZATION_LEVEL)]
