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中，引入了一种新的编程模式，称为面向协议编程。

创建型模式:

在swift中，Struct是一种自动克隆的值类型。因此，我们可以免费获得实现原型模式所需的行为。

而类是引用类型，在赋值过程中不会自动克隆。为了实现原型模式，类必须采用NSCopying协议。

浅拷贝只复制指向那些对象的引用，而深拷贝复制对象的引用。

为每种引用类型实现深度复制已成为一项乏味的任务。如果类包含进一步的引用类型，我们必须为每个引用属性实现原型模式。然后我们需要通过实现NSCopying协议复制整个对象图。

class Contact{
  var firstName:String
  var lastName:String
  var workAddress:Address // Reference type
}

class Address{
   var street:String
   ...
} 

通过使用结构体和枚举，我们使我们的代码更简单，因为我们不需要实现复制逻辑。

我不会说结构体提供的功能更少。

当然，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)")
}

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

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

许多Cocoa api需要NSObject子类，这迫使你使用class。但除此之外，你可以使用以下苹果Swift博客中的案例来决定是使用struct / enum值类型还是类引用类型。

https://developer.apple.com/swift/blog/?id=10

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