这个问题似乎是重复的，但无论如何，下面的问题将回答大多数用例:

One of the most important differences between structures and classes is that structures are value types and are always copied when they are passed around in your code, and classes are reference type and are passed by reference. Also, classes have Inheritance which allows one class to inherit the characteristics of another. Struct properties are stored on Stack and Class instances are stored on Heap hence, sometimes the stack is drastically faster than a class. Struct gets a default initializer automatically whereas in Class, we have to initialize. Struct is thread safe or singleton at any point of time.

而且, 要总结结构和类之间的区别，有必要了解值类型和引用类型之间的区别。

在复制值类型时，它将从其中复制所有数据 你要复制到新变量中的东西。它们是分开的 事物和改变一个并不影响另一个。 复制引用类型时，新变量引用 与你要复制的东西相同的内存位置。这意味着 改变一个会改变另一个因为它们都指向 相同的内存位置。 下面的示例代码可以作为参考。

/ / sampleplayground.playground

  class MyClass {
        var myName: String
        init(myName: String){
            self.myName = myName;
        }
    }

    var myClassExistingName = MyClass(myName: "DILIP")
    var myClassNewName = myClassExistingName
    myClassNewName.myName = "John"


    print("Current Name: ",myClassExistingName.myName)
    print("Modified Name", myClassNewName.myName)

    print("*************************")

    struct myStruct {
        var programmeType: String
        init(programmeType: String){
            self.programmeType = programmeType
        }
    }

    var myStructExistingValue = myStruct(programmeType: "Animation")
    var myStructNewValue = myStructExistingValue
    myStructNewValue.programmeType = "Thriller"

    print("myStructExistingValue: ", myStructExistingValue.programmeType)
    print("myStructNewValue: ", myStructNewValue.programmeType)

输出:

Current Name:  John
Modified Name John
*************************
myStructExistingValue:  Animation
myStructNewValue:  Thriller

类和结构都可以做到:

定义属性来存储值 定义提供功能的方法 被扩展 遵守协议 定义初始化 定义下标以提供对其变量的访问

唯一的类可以做到:

继承 铸字 定义deinitialisers 允许多个引用进行引用计数。

已经有很多关于这方面的文章了，我想在这里加一个类比。希望你看完这篇文章后，心中永远不会再有疑虑: 底线: 类通过引用传递，而结构通过值传递。

假设你和你的朋友共享一个谷歌文档表。现在，如果他改变了其中的任何内容，你也会在谷歌文档上看到变化，这意味着你的副本也受到了影响。 这基本上是“通过引用传递”。

但假设，如果你有一个。xls文件保存在你的机器。你把那份文件交给你的朋友。现在，如果他在那个文件中做了任何更改，你的文件也不会被打乱/影响，因为你有自己的副本。 这基本上就是“按值传递”。 你有多个简单的程序已经在那里检查这个类比在快速操场。

正如许多人已经指出复制结构体和类的区别一样，这可以从它们在c语言中的来源来理解，像这样的结构体

struct A {
    let a: Int
    let c: Bool
}

在func父对象或结构体的局部内存中，它将是这样的

64bit for int
8 bytes for bool

现在

class A {
    let a: Int
    let c: Bool
}

而不是存储在本地内存或结构或类中的数据内容，它将是一个单一指针

64bit address of class A instance

当你复制这两个时，很容易看出为什么会有区别，复制第一个，你复制了64位的int和8位的bool，复制第二个，你复制了64位的地址到A类的实例，你可以有同一个内存地址的多个副本，都指向同一个实例，但结构体的每个副本都将是它自己的副本。

现在事情变得复杂了因为你可以把这两个混合起来

struct A {
    let a: ClassA
    let c: Bool
}

你的记忆会是这样的

64bit address of class A instance
8 bytes for bool

This is a problem because even though you have multiple copies of the struct in your program, they all have a copy to the same object ClassA, this means just like multiples reference to instance ClassA you pass around have to have a reference count kept of how many reference to the object exists to know when to delete them, you program can have multiple references to struct A that need to keep a reference count to their ClassA instances, this can be time consuming if your struct has a lot of classes in them, or the structs it contains has lots of classes in them, now when you copy your struct, the compiler has to generate code that goes through every single class instance referenced in your struct and substructs, and increment there reference count to keep track of how many references there are. This can make classes much faster to pass around as you just need to copy its single address, and it won't need to increase the reference count of any of its children because it want reduce the reference count of any child it contains until its own reference count reaches 0.

The thing gets even more complicated with some Apple struct types, that they actually have object types in them, the good thing about data that is reference to, is it can be stored in memory and be lengthened and contractor at will and they can be very large, unlike data stored on local stack, so types like String, Array, Set, Dictionary though they act like struct and will even make a duplicate of there internal data if you try to modify them so you don't change all occurrence, there data still has to be reference counted and so a struct containing a lots of these types can still be slow, because the internal data for each one has to be retained.

当然，传递结构类型可以减少大量错误的可能性，但它们也会降低程序的速度，这取决于所包含的类型。

斯威夫特类型

命名类型或标称类型或有名称的类型 复合类型或非名义类型或没有名称的类型

值类型是一种类型，其值在赋值给变量或常量、传递给函数或从函数返回时被复制。(as and is检查构造的副本)

当引用类型被赋值给变量或常量，或者被传递给函数时，引用类型不会被复制

值类型:

Struct, Enum[About]，元组 struct String, struct Array(Set, Dictionary)

(objective - c int…)

字符串，内置集合值类型包含对堆的内部引用，以管理它的大小

当您分配或传递值类型时，将创建数据的新副本。copy on write - COW机制用于某些特定的类(如Collections(Array, Dictionary, Set))[About]，并进行了一些优化，例如在修改对象时创建副本。对于自定义类型，您应该自己支持COW 当你修改一个实例时，它只在局部起作用。 如果Value为局部变量，则使用堆栈内存[关于]

引用类型: 类,函数

(Objective-C所有其他)

使用ARC

当你分配或传递引用类型时，一个新的引用将被创建到原始实例(实例的地址被复制)。 当您修改一个实例时，它会产生全局影响，因为该实例可以被指向它的任何引用共享和访问。 通常使用堆内存[大约]

建议默认为“type”。Value类型的最大优点是它们通常是线程安全的

参考类型

它们可以遗传， 可以使用Deinit ()， 通过引用===比较实例， Objective-C互操作性，因为值类型是在Swift中引入的。

[堆栈vs堆] [let vs var, class vs struct] [类别vs结构]

在结构和类之间选择 类型 类和结构

Usually (in most programming languages), objects are blocks of data that are stored on heap, and then a reference (normally a pointer) to these blocks, contains a name is using to access these blocks of data. This mechanism allows sharing objects in the heap by copying the value of their references (pointers). This is not the case of basic data types such as Integers, and that is because the memory needed to create a reference is almost the same as the object (in this case integer value). Thus, they will be passed as values not as a reference in the case of large objects.

Swift使用struct来提高String和Array对象的性能。

这是一本很好的读物