玩Swift，来自Java背景，为什么要选择Struct而不是Class?看起来它们是一样的东西，只不过Struct提供的功能更少。那为什么选择它呢?
当前回答
我不会说结构体提供的功能更少。
当然，self是不可变的，除了在突变函数中，但仅此而已。
继承可以很好地工作，只要您坚持每个类都应该是抽象的或最终的。
将抽象类实现为协议，将最终类实现为结构。
struct的好处是你可以在不创建共享可变状态的情况下使你的字段可变，因为写时复制会照顾到这一点:)
这就是为什么下面例子中的属性/字段都是可变的，我不会在Java或c#或swift类中这样做。
示例继承结构，在底部名为" Example "的函数中有一点脏和直接的用法:
protocol EventVisitor
{
func visit(event: TimeEvent)
func visit(event: StatusEvent)
}
protocol Event
{
var ts: Int64 { get set }
func accept(visitor: EventVisitor)
}
struct TimeEvent : Event
{
var ts: Int64
var time: Int64
func accept(visitor: EventVisitor)
{
visitor.visit(self)
}
}
protocol StatusEventVisitor
{
func visit(event: StatusLostStatusEvent)
func visit(event: StatusChangedStatusEvent)
}
protocol StatusEvent : Event
{
var deviceId: Int64 { get set }
func accept(visitor: StatusEventVisitor)
}
struct StatusLostStatusEvent : StatusEvent
{
var ts: Int64
var deviceId: Int64
var reason: String
func accept(visitor: EventVisitor)
{
visitor.visit(self)
}
func accept(visitor: StatusEventVisitor)
{
visitor.visit(self)
}
}
struct StatusChangedStatusEvent : StatusEvent
{
var ts: Int64
var deviceId: Int64
var newStatus: UInt32
var oldStatus: UInt32
func accept(visitor: EventVisitor)
{
visitor.visit(self)
}
func accept(visitor: StatusEventVisitor)
{
visitor.visit(self)
}
}
func readEvent(fd: Int) -> Event
{
return TimeEvent(ts: 123, time: 56789)
}
func example()
{
class Visitor : EventVisitor
{
var status: UInt32 = 3;
func visit(event: TimeEvent)
{
print("A time event: \(event)")
}
func visit(event: StatusEvent)
{
print("A status event: \(event)")
if let change = event as? StatusChangedStatusEvent
{
status = change.newStatus
}
}
}
let visitor = Visitor()
readEvent(1).accept(visitor)
print("status: \(visitor.status)")
}
其他回答
结构比类快得多。同样，如果你需要继承，那么你必须使用Class。最重要的一点是类是引用类型，而结构是值类型。例如,
class Flight {
var id:Int?
var description:String?
var destination:String?
var airlines:String?
init(){
id = 100
description = "first ever flight of Virgin Airlines"
destination = "london"
airlines = "Virgin Airlines"
}
}
struct Flight2 {
var id:Int
var description:String
var destination:String
var airlines:String
}
现在让我们创建两者的实例。
var flightA = Flight()
var flightB = Flight2.init(id: 100, description:"first ever flight of Virgin Airlines", destination:"london" , airlines:"Virgin Airlines" )
现在让我们将这些实例传递给两个修改id、描述、目的地等的函数。
func modifyFlight(flight:Flight) -> Void {
flight.id = 200
flight.description = "second flight of Virgin Airlines"
flight.destination = "new york"
flight.airlines = "Virgin Airlines"
}
同时,
func modifyFlight2(flight2: Flight2) -> Void {
var passedFlight = flight2
passedFlight.id = 200
passedFlight.description = "second flight from virgin airlines"
}
so,
modifyFlight(flight: flightA)
modifyFlight2(flight2: flightB)
现在如果我们打印航班a的id和描述，我们得到
id = 200
description = "second flight of Virgin Airlines"
在这里，我们可以看到FlightA的id和描述被改变了，因为传递给modify方法的参数实际上指向FlightA对象(引用类型)的内存地址。
现在如果我们打印FLightB实例的id和描述，
id = 100
description = "first ever flight of Virgin Airlines"
这里我们可以看到FlightB实例没有改变，因为在modifyFlight2方法中，Flight2的实际实例是传递而不是引用(值类型)。
我不会说结构体提供的功能更少。
当然，self是不可变的，除了在突变函数中，但仅此而已。
继承可以很好地工作，只要您坚持每个类都应该是抽象的或最终的。
将抽象类实现为协议，将最终类实现为结构。
struct的好处是你可以在不创建共享可变状态的情况下使你的字段可变，因为写时复制会照顾到这一点:)
这就是为什么下面例子中的属性/字段都是可变的，我不会在Java或c#或swift类中这样做。
示例继承结构，在底部名为" Example "的函数中有一点脏和直接的用法:
protocol EventVisitor
{
func visit(event: TimeEvent)
func visit(event: StatusEvent)
}
protocol Event
{
var ts: Int64 { get set }
func accept(visitor: EventVisitor)
}
struct TimeEvent : Event
{
var ts: Int64
var time: Int64
func accept(visitor: EventVisitor)
{
visitor.visit(self)
}
}
protocol StatusEventVisitor
{
func visit(event: StatusLostStatusEvent)
func visit(event: StatusChangedStatusEvent)
}
protocol StatusEvent : Event
{
var deviceId: Int64 { get set }
func accept(visitor: StatusEventVisitor)
}
struct StatusLostStatusEvent : StatusEvent
{
var ts: Int64
var deviceId: Int64
var reason: String
func accept(visitor: EventVisitor)
{
visitor.visit(self)
}
func accept(visitor: StatusEventVisitor)
{
visitor.visit(self)
}
}
struct StatusChangedStatusEvent : StatusEvent
{
var ts: Int64
var deviceId: Int64
var newStatus: UInt32
var oldStatus: UInt32
func accept(visitor: EventVisitor)
{
visitor.visit(self)
}
func accept(visitor: StatusEventVisitor)
{
visitor.visit(self)
}
}
func readEvent(fd: Int) -> Event
{
return TimeEvent(ts: 123, time: 56789)
}
func example()
{
class Visitor : EventVisitor
{
var status: UInt32 = 3;
func visit(event: TimeEvent)
{
print("A time event: \(event)")
}
func visit(event: StatusEvent)
{
print("A status event: \(event)")
if let change = event as? StatusChangedStatusEvent
{
status = change.newStatus
}
}
}
let visitor = Visitor()
readEvent(1).accept(visitor)
print("status: \(visitor.status)")
}
对于类，您获得继承并通过引用传递，而结构则没有继承并通过值传递。
有很多关于Swift的WWDC会议，其中一个会议详细回答了这个问题。确保你看了这些，因为它会让你更快地跟上语言指南或iBook。
结构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)]
根据2015年非常流行的WWDC演讲，Swift中面向协议的编程(视频，文本)，Swift提供了许多特性，使得结构在很多情况下比类更好。
如果结构相对较小且可复制，则更可取，因为复制比类中对同一个实例有多个引用要安全得多。当将一个变量传递给多个类和/或多线程环境时，这一点尤其重要。如果你总是可以将变量的副本发送到其他地方，你就不必担心其他地方会改变你下面变量的值。
使用Structs，不太需要担心内存泄漏或多个线程竞相访问/修改变量的单个实例。(对于更有技术头脑的人来说，例外情况是在闭包内捕获结构时，因为它实际上是在捕获实例的引用，除非您显式地将其标记为要复制)。
类也可能变得臃肿，因为一个类只能继承一个超类。这鼓励我们创建巨大的超类，其中包含许多不同的能力，而这些能力之间只有松散的关联。使用协议，特别是使用可以为协议提供实现的协议扩展，允许您消除实现此类行为所需的类。
演讲列出了优先使用类的这些场景:
复制或比较实例没有意义(例如，Window) 实例生命周期与外部效果(例如，TemporaryFile)相关联。 实例只是“接收器”——只写外部状态的管道(例如cgcontext)
这意味着结构应该是默认的，而类应该是备用的。
另一方面，Swift编程语言文档有些矛盾:
Structure instances are always passed by value, and class instances are always passed by reference. This means that they are suited to different kinds of tasks. As you consider the data constructs and functionality that you need for a project, decide whether each data construct should be defined as a class or as a structure. As a general guideline, consider creating a structure when one or more of these conditions apply: The structure’s primary purpose is to encapsulate a few relatively simple data values. It is reasonable to expect that the encapsulated values will be copied rather than referenced when you assign or pass around an instance of that structure. Any properties stored by the structure are themselves value types, which would also be expected to be copied rather than referenced. The structure does not need to inherit properties or behavior from another existing type. Examples of good candidates for structures include: The size of a geometric shape, perhaps encapsulating a width property and a height property, both of type Double. A way to refer to ranges within a series, perhaps encapsulating a start property and a length property, both of type Int. A point in a 3D coordinate system, perhaps encapsulating x, y and z properties, each of type Double. In all other cases, define a class, and create instances of that class to be managed and passed by reference. In practice, this means that most custom data constructs should be classes, not structures.
在这里，它声称我们应该只在特定的情况下默认使用类和使用结构。最后，您需要了解值类型与引用类型的实际含义，然后才能就何时使用结构或类做出明智的决定。此外，请记住，这些概念一直在发展，Swift编程语言文档是在面向协议编程演讲之前编写的。
