在这些回答中没有注意到的一点是，持有类和结构的变量可以是let，同时仍然允许对对象的属性进行更改，而对于结构则不能这样做。

如果你不希望变量指向另一个对象，但仍然需要修改对象，即在有许多实例变量的情况下，你希望一个接一个地更新，这是很有用的。如果它是一个结构，你必须允许变量被重置为另一个对象使用var，因为在Swift常量值类型正确地允许零突变，而引用类型(类)不这样做。

假设我们知道Struct是值类型，Class是引用类型。

如果你不知道值类型和引用类型是什么，那么看看按引用传递和按值传递之间的区别是什么?

根据mikeash的帖子:

... Let's look at some extreme, obvious examples first. Integers are obviously copyable. They should be value types. Network sockets can't be sensibly copied. They should be reference types. Points, as in x, y pairs, are copyable. They should be value types. A controller that represents a disk can't be sensibly copied. That should be a reference type. Some types can be copied but it may not be something you want to happen all the time. This suggests that they should be reference types. For example, a button on the screen can conceptually be copied. The copy will not be quite identical to the original. A click on the copy will not activate the original. The copy will not occupy the same location on the screen. If you pass the button around or put it into a new variable you'll probably want to refer to the original button, and you'd only want to make a copy when it's explicitly requested. That means that your button type should be a reference type. View and window controllers are a similar example. They might be copyable, conceivably, but it's almost never what you'd want to do. They should be reference types. What about model types? You might have a User type representing a user on your system, or a Crime type representing an action taken by a User. These are pretty copyable, so they should probably be value types. However, you probably want updates to a User's Crime made in one place in your program to be visible to other parts of the program. This suggests that your Users should be managed by some sort of user controller which would be a reference type. e.g struct User {} class UserController { var users: [User] func add(user: User) { ... } func remove(userNamed: String) { ... } func ... } Collections are an interesting case. These include things like arrays and dictionaries, as well as strings. Are they copyable? Obviously. Is copying something you want to happen easily and often? That's less clear. Most languages say "no" to this and make their collections reference types. This is true in Objective-C and Java and Python and JavaScript and almost every other language I can think of. (One major exception is C++ with STL collection types, but C++ is the raving lunatic of the language world which does everything strangely.) Swift said "yes," which means that types like Array and Dictionary and String are structs rather than classes. They get copied on assignment, and on passing them as parameters. This is an entirely sensible choice as long as the copy is cheap, which Swift tries very hard to accomplish. ...

我个人不会这样命名我的类。我通常将我的命名为UserManager而不是UserController，但想法是一样的

另外，当你必须重写一个函数的每个实例(即它们没有任何共享功能)时，不要使用类。

所以不是一个类的几个子类。使用几个符合协议的结构体。

使用结构体的另一种合理情况是，当你想对新旧模型进行delta/diff运算时。对于引用类型，你不能开箱即用。对于值类型，突变是不共享的。

一些好处:

由于不可共享，自动线程安全 由于没有isa和refcount，使用更少的内存(实际上通常是堆栈分配) 方法总是静态分派的，所以可以内联(尽管@final可以为类这样做) 更容易推理(不需要“防御性复制”，这是典型的NSArray, NSString等…)出于与线程安全相同的原因

结构比类快得多。同样，如果你需要继承，那么你必须使用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的实际实例是传递而不是引用(值类型)。

以下是一些值得考虑的其他原因:

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

根据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编程语言文档是在面向协议编程演讲之前编写的。