As struct are value types and you can create the memory very easily which stores into stack.Struct can be easily accessible and after the scope of the work it's easily deallocated from the stack memory through pop from the top of the stack. On the other hand class is a reference type which stores in heap and changes made in one class object will impact to other object as they are tightly coupled and reference type.All members of a structure are public whereas all the members of a class are private.

struct的缺点是不能被继承。

Structure and class are user defied data types By default, structure is a public whereas class is private Class implements the principal of encapsulation Objects of a class are created on the heap memory Class is used for re usability whereas structure is used for grouping the data in the same structure Structure data members cannot be initialized directly but they can be assigned by the outside the structure Class data members can be initialized directly by the parameter less constructor and assigned by the parameterized constructor

这个答案最初是关于结构和类之间性能的差异。不幸的是，关于我使用的测量方法有太多的争议。我把它留在下面，但请不要过多地去理解它。我认为经过这么多年，在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://docs.swift.org/swift-book/LanguageGuide/ClassesAndStructures.html

---

额外的信息

Swift值类型保存在堆栈中。在进程中，每个线程都有自己的堆栈空间，因此没有其他线程能够直接访问您的值类型。因此，没有竞争条件、锁、死锁或任何相关的线程同步复杂性。

值类型不需要动态内存分配或引用计数，这两者都是昂贵的操作。同时，值类型上的方法是静态分派的。就性能而言，这为值类型创造了巨大的优势。

作为提醒，这里有一个Swift列表

值类型:

结构体 枚举 元组 基本类型(Int, Double, Bool等) 集合(数组，字符串，字典，集合)

引用类型:

类 任何来自NSObject的东西 函数 关闭

从值类型和引用类型的角度来回答这个问题，从苹果博客的这篇文章来看，它看起来非常简单:

使用值类型[例如struct, enum]: 用==比较实例数据是有意义的 你希望副本有独立的状态 这些数据将在代码中跨多个线程使用 在以下情况下使用引用类型[例如class]: 比较实例标识和===是有意义的 您希望创建共享的、可变的状态

正如在那篇文章中提到的，没有可写属性的类将与结构体的行为相同，但有一点需要注意:结构体最适合线程安全模型——这是现代应用程序架构中日益迫切的需求。

对于类，您获得继承并通过引用传递，而结构则没有继承并通过值传递。

有很多关于Swift的WWDC会议，其中一个会议详细回答了这个问题。确保你看了这些，因为它会让你更快地跟上语言指南或iBook。