Javaのバックグラウンドから来たSwiftで遊んでいるのに、なぜクラスではなく構造体を選択したいのですか？Structが提供する機能が少ないという点で、同じもののようです。なぜそれを選ぶのですか？

非常に人気のあるWWDC2015トークのSwiftでのプロトコル指向プログラミング（ビデオ、トランスクリプト）によると、Swiftは、多くの状況でクラスよりも構造体を優れたものにする多くの機能を提供します。

構造体は、クラスで発生するように同じインスタンスへの複数の参照を持つよりもコピーの方がはるかに安全であるため、比較的小さくコピー可能である場合に適しています。これは、変数を多くのクラスに渡す場合やマルチスレッド環境で特に重要です。変数のコピーをいつでも他の場所に送信できる場合は、他の場所で変数の値が変更されることを心配する必要はありません。

Structsを使用すると、変数の単一インスタンスにアクセス/変更するためにメモリリークや複数のスレッドが競合することを心配する必要がはるかに少なくなります。（技術的には、クロージャ内の構造体をキャプチャする場合は例外です。明示的にコピーするようにマークしない限り、インスタンスへの参照を実際にキャプチャするためです）。

クラスは単一のスーパークラスからしか継承できないため、クラスが肥大化する可能性もあります。それは私たちが大まかにしか関連していない多くの異なる能力を包含する巨大なスーパークラスを作成することを奨励します。プロトコルを使用すると、特にプロトコルに実装を提供できるプロトコル拡張機能を使用すると、この種の動作を実現するためのクラスの必要性を排除できます。

講演では、クラスが優先される次のシナリオについて説明します。

• インスタンスをコピーまたは比較しても意味がありません（例：ウィンドウ）
• インスタンスの存続期間は、外部効果（TemporaryFileなど）に関連付けられています
• インスタンスは単なる「シンク」であり、外部状態への書き込み専用コンジット（egCGContext）

これは、構造体をデフォルトにし、クラスをフォールバックにする必要があることを意味します。

一方、Swiftプログラミング言語のドキュメントは多少矛盾しています。

構造体インスタンスは常に値によって渡され、クラスインスタンスは常に参照によって渡されます。これは、それらがさまざまな種類のタスクに適していることを意味します。プロジェクトに必要なデータ構成と機能を検討するときは、各データ構成をクラスとして定義するか、構造として定義するかを決定します。

一般的なガイドラインとして、次の1つ以上の条件が当てはまる場合は、構造を作成することを検討してください。

• この構造の主な目的は、いくつかの比較的単純なデータ値をカプセル化することです。
• その構造体のインスタンスを割り当てたり、渡したりするときに、カプセル化された値が参照されるのではなく、コピーされることを期待するのは合理的です。
• 構造によって格納されるプロパティは、それ自体が値型であり、参照されるのではなくコピーされることが期待されます。
• 構造体は、別の既存のタイプからプロパティや動作を継承する必要はありません。

構造の適切な候補の例は次のとおりです。

• 幾何学的形状のサイズ。おそらく、幅プロパティと高さプロパティをカプセル化しており、どちらもDouble型です。
• 一連の範囲内の範囲を参照する方法。おそらく、両方ともInt型のstartプロパティとlengthプロパティをカプセル化します。
• 3D座標系のポイントで、それぞれがDouble型のx、y、zプロパティをカプセル化している可能性があります。

それ以外の場合はすべて、クラスを定義し、そのクラスのインスタンスを作成して、参照によって管理および渡されます。実際には、これは、ほとんどのカスタムデータ構造が構造ではなくクラスであるべきであることを意味します。

ここでは、デフォルトでクラスを使用し、特定の状況でのみ構造を使用する必要があると主張しています。最終的には、値型と参照型の実際の影響を理解する必要があります。そうすれば、構造体またはクラスをいつ使用するかについて情報に基づいた決定を下すことができます。また、これらの概念は常に進化しており、Swiftプログラミング言語のドキュメントはプロトコル指向プログラミングの講演が行われる前に作成されたことを忘れないでください。

構造体インスタンスはスタックに割り当てられ、クラスインスタンスはヒープに割り当てられるため、構造体の速度が大幅に向上する場合があります。

ただし、常に自分で測定し、独自のユースケースに基づいて決定する必要があります。

とIntを使用structしてデータ型をラップする2つの戦略を示す次の例について考えてみますclass。複数のフィールドがある現実の世界をよりよく反映するために、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でリリースビルドを実行している場合、Swiftコンパイラの設定は-O -whole-module-optimization次のとおりです。

• class バージョンは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でリリースビルドを実行し、5回の実行で平均すると、Swiftコンパイラの設定は-O -whole-module-optimization次のようになります。

• class バージョンは2.159942142秒かかりました
• struct バージョンは5.83E-08sかかりました（37,000,000倍高速）

注：実際のシナリオでは、構造体に複数のフィールドが存在する可能性があると誰かが言ったように、1ではなく10のフィールドを持つ構造体/クラスのテストを追加しました。驚くべきことに、結果はそれほど変わりません。

元の結果（2014年6月1日）：

（10ではなく1つのフィールドを持つ構造体/クラスで実行）

Swift 1.2、Xcode 6.3.2の時点で、iPhone 5S、iOS 8.3でリリースビルドを実行し、5回の実行で平均

• class バージョンは9.788332333秒かかりました
• struct バージョンは0.010532942秒かかりました（900倍高速）

古い結果（不明な時間から）

（10ではなく1つのフィールドを持つ構造体/クラスで実行）

私のMacBookProのリリースビルドでは：

• classバージョンは1.10082秒かかりました
• structバージョンは0.02324秒（50倍の速さ）を取りました

構造体とクラスの類似点。

簡単な例でこの要点を作成しました。 https://github.com/objc-swift/swift-classes-vs-structures

そして違い

1.継承。

構造体は迅速に継承できません。お望みならば

class Vehicle{
}

class Car : Vehicle{
}

クラスに行きなさい。

2.通りすがり

Swift構造体は値を渡し、クラスインスタンスは参照を渡します。

コンテキストの違い

構造体定数と変数

例（WWDC 2014で使用）

struct Point{
 
   var x = 0.0;
   var y = 0.0;

} 

Pointと呼ばれる構造体を定義します。

var point = Point(x:0.0,y:2.0)

xを変更しようとすると。その有効な表現。

point.x = 5

しかし、ポイントを定数として定義した場合。

let point = Point(x:0.0,y:2.0)
point.x = 5 //This will give compile time error.

この場合、ポイント全体が不変の定数です。

代わりにクラスPointを使用した場合、これは有効な式です。クラス内の不変定数は、インスタンス変数ではなくクラス自体への参照であるため（定数として定義されている変数を除く）

Structが値型であり、Classが参照型であることがわかっていると仮定します。

_{値型と参照型がわからない場合は、参照による受け渡しと値による受け渡しの違いは何ですか？を参照してください。}

mikeashの投稿に基づく：

...最初にいくつかの極端で明白な例を見てみましょう。整数は明らかにコピー可能です。それらは値型でなければなりません。ネットワークソケットは適切にコピーできません。それらは参照型である必要があります。x、yペアのように、ポイントはコピー可能です。それらは値型でなければなりません。ディスクを表すコントローラーは、適切にコピーすることはできません。それは参照型である必要があります。

一部のタイプはコピーできますが、常に実行したいものではない場合があります。これは、それらが参照型であるべきであることを示唆しています。たとえば、画面上のボタンを概念的にコピーできます。コピーはオリジナルと完全に同一ではありません。コピーをクリックしても、オリジナルはアクティブになりません。コピーは画面上の同じ場所を占めることはありません。ボタンを渡すか、新しい変数に入れる場合は、おそらく元のボタンを参照する必要があり、明示的に要求された場合にのみコピーを作成する必要があります。つまり、ボタンタイプは参照タイプである必要があります。

ビューコントローラとウィンドウコントローラは同様の例です。それらはおそらくコピー可能かもしれませんが、それはあなたがやりたいことではほとんどありません。それらは参照型である必要があります。

モデルタイプはどうですか？システム上のユーザーを表すユーザータイプ、またはユーザーが実行したアクションを表す犯罪タイプがある場合があります。これらはかなりコピー可能であるため、おそらく値型である必要があります。ただし、プログラムの1つの場所で行われたユーザーの犯罪の更新を、プログラムの他の部分に表示したい場合があります。 これは、ユーザーが参照型となるある種のユーザーコントローラーによって管理される必要があることを示唆しています。例えば

struct User {}
class UserController {
    var users: [User]

    func add(user: User) { ... }
    func remove(userNamed: String) { ... }
    func ...
}

コレクションは興味深い事例です。これらには、文字列だけでなく、配列や辞書なども含まれます。それらはコピー可能ですか？明らかに。あなたが簡単にそして頻繁に起こりたいことをコピーしていますか？それはあまり明確ではありません。

ほとんどの言語はこれに「いいえ」と言い、コレクションを参照型にします。これは、Objective-CとJava、PythonとJavaScript、そして私が考えることができる他のほとんどすべての言語に当てはまります。（1つの主要な例外はSTLコレクションタイプのC ++ですが、C ++は、すべてを奇妙に行う言語の世界の熱狂的な狂信者です。）

Swiftは「はい」と言いました。これは、Array、Dictionary、Stringなどの型がクラスではなく構造体であることを意味します。それらは、割り当て時、およびパラメーターとして渡すときにコピーされます。コピーが安い限り、これは完全に賢明な選択であり、Swiftはそれを達成するために非常に懸命に努力しています。..。

_{私は個人的にクラスにそのような名前を付けていません。私は通常、UserControllerではなくUserManagerという名前を付けていますが、考え方は同じです。}

さらに、関数のすべてのインスタンスをオーバーライドする必要がある場合、つまり共有機能を持たない場合は、クラスを使用しないでください。

したがって、クラスのいくつかのサブクラスを持つ代わりに。プロトコルに準拠するいくつかの構造体を使用します。

構造体のもう1つの合理的なケースは、古いモデルと新しいモデルのデルタ/差分を実行する場合です。参照タイプでは、箱から出してそれを行うことはできません。値型では、ミューテーションは共有されません。

考慮すべきその他の理由は次のとおりです。

1. 構造体は、コードで維持する必要のない自動初期化子を取得します。

   struct MorphProperty {
      var type : MorphPropertyValueType
      var key : String
      var value : AnyObject
   
      enum MorphPropertyValueType {
          case String, Int, Double
      }
    }
   
    var m = MorphProperty(type: .Int, key: "what", value: "blah")
   

これをクラスで取得するには、初期化子を追加し、初期化子を維持する必要があります...

1. のような基本的なコレクションタイプArrayは構造体です。独自のコードでそれらを使用すればするほど、参照ではなく値を渡すことに慣れます。例えば：

   func removeLast(var array:[String]) {
      array.removeLast()
      println(array) // [one, two]
   }
   
   var someArray = ["one", "two", "three"]
   removeLast(someArray)
   println(someArray) // [one, two, three]
   

2. どうやら不変性と可変性は大きなトピックですが、多くの賢い人々は不変性（この場合は構造体）が望ましいと考えています。可変オブジェクトと不変オブジェクト

いくつかの利点：

• 共有できないため、自動的にスレッドセーフ
• 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、説明、宛先などを変更する2つの関数に渡します。

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" 
}

そう、

modifyFlight(flight: flightA)
modifyFlight2(flight2: flightB)

これで、flightAのIDと説明を印刷すると、次のようになります。

id = 200
description = "second flight of Virgin Airlines"

ここでは、modifyメソッドに渡されたパラメーターが実際にはflightAオブジェクト（参照型）のメモリアドレスを指しているため、FlightAのIDと説明が変更されていることがわかります。

ここで、取得したFLightBインスタンスのIDと説明を出力すると、

id = 100
description = "first ever flight of Virgin Airlines"

ここでは、modifyFlight2メソッドでは、Flight2の実際のインスタンスが参照（値型）ではなくパスであるため、FlightBインスタンスが変更されていないことがわかります。

Structsありvalue type、Classesありreference type

• 値型は参照型よりも高速です
• 値型インスタンスは、複数のスレッドが競合状態やデッドロックを心配することなくインスタンスを変更できるため、マルチスレッド環境で安全です。
• 値型には、参照型とは異なり、参照はありません。したがって、メモリリークは発生しません。

次のvalue場合にタイプを使用します。

• コピーに独立した状態を持たせたい場合、データは複数のスレッドにわたるコードで使用されます

次のreference場合にタイプを使用します。

• 共有された可変状態を作成したいとします。

詳細については、Appleのドキュメントにも記載されています。

https://docs.swift.org/swift-book/LanguageGuide/ClassesAndStructures.html

追加情報

Swiftの値型はスタックに保持されます。プロセスでは、各スレッドに独自のスタックスペースがあるため、他のスレッドが値型に直接アクセスすることはできません。したがって、競合状態、ロック、デッドロック、または関連するスレッド同期の複雑さはありません。

値型は、動的なメモリ割り当てや参照カウントを必要としません。どちらもコストのかかる操作です。同時に、値型のメソッドは静的にディスパッチされます。これらは、パフォーマンスの観点から値型を支持する大きな利点を生み出します。

ここにリマインダーとしてSwiftのリストがあります

値のタイプ：

• 構造体
• 列挙型
• タプル
• プリミティブ（Int、Double、Boolなど）
• コレクション（配列、文字列、辞書、セット）

参照型：

• クラス
• NSObjectから来るものすべて
• 関数
• 閉鎖

値型と参照型の観点から質問に答えると、このAppleブログ投稿からは非常に単純に見えます。

次の場合に値型[例：struct、enum]を使用します。

• インスタンスデータを==と比較することは理にかなっています
• コピーに独立した状態を持たせたい
• データは複数のスレッドにわたるコードで使用されます

次の場合に参照型[例：クラス]を使用します。

• インスタンスIDを===と比較することは理にかなっています
• 共有された可変状態を作成したい

その記事で述べたように、書き込み可能なプロパティのないクラスは構造体と同じように動作しますが、1つの注意点があります：構造体はスレッドセーフモデルに最適です-現代のアプリアーキテクチャでますます差し迫った要件です。

継承を取得して参照によって渡されるクラスでは、構造体には継承がなく、値によって渡されます。

Swiftには素晴らしいWWDCセッションがあり、この特定の質問はそのうちの1つで詳細に回答されています。言語ガイドやiBookよりもはるかに速くスピードアップできるので、必ずそれらを見てください。

構造体が提供する機能が少ないとは言えません。

確かに、自己は突然変異関数を除いて不変ですが、それだけです。

すべてのクラスは抽象的または最終的である必要があるという古き良き考えに固執する限り、継承は正常に機能します。

抽象クラスをプロトコルとして実装し、最終クラスを構造体として実装します。

構造体の良いところは、コピーオンライトがそれを処理するため、共有の可変状態を作成せずにフィールドを可変にすることができることです:)

そのため、次の例のプロパティ/フィールドはすべて変更可能です。これは、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では、プロトコル指向プログラミングとして知られる新しいプログラミングパターンが導入されました。

作成パターン：

迅速に、Structは自動的に複製される値型です。したがって、プロトタイプパターンを無料で実装するために必要な動作を取得します。

一方、クラスは参照型であり、割り当て中に自動的に複製されません。プロトタイプパターンを実装するには、クラスはNSCopyingプロトコルを採用する必要があります。

浅いコピーはそれらのオブジェクトを指す参照のみを複製しますが、深いコピーはオブジェクトの参照を複製します。

参照型ごとにディープコピーを実装することは、面倒な作業になりました。クラスにさらに参照型が含まれている場合は、参照プロパティごとにプロトタイプパターンを実装する必要があります。次に、プロトコルを実装して、オブジェクトグラフ全体を実際にコピーする必要があります。NSCopying

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

class Address{
   var street:String
   ...
} 

構造体と列挙型を使用することで、コピーロジックを実装する必要がないため、コードが単純になりました。

多くのCocoaAPIにはNSObjectサブクラスが必要であるため、クラスを使用する必要があります。ただし、それ以外に、AppleのSwiftブログの次のケースを使用して、構造体/列挙型の値型とクラス参照型のどちらを使用するかを決定できます。

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

これらの回答で注目されていない1つのポイントは、クラスと構造体を保持する変数はlet、オブジェクトのプロパティの変更を許可している間はある可能性がありますが、構造体ではこれを行うことができないということです。

これは、変数が別のオブジェクトを指すことを望まないが、オブジェクトを変更する必要がある場合、つまり、次々に更新するインスタンス変数が多数ある場合に役立ちます。構造体の場合、これを行うには、変数を別のオブジェクトに完全にリセットできるようにする必要があります。varこれは、Swiftの定数値型ではミューテーションがゼロであるのに対し、参照型（クラス）はこのように動作しないためです。

構造体は値型であり、スタックに格納するメモリを非常に簡単に作成できます。構造体は簡単にアクセスでき、作業の範囲の後で、スタックの先頭からポップを介してスタックメモリから簡単に割り当てを解除できます。一方、クラスはヒープに格納される参照型であり、1つのクラスオブジェクトで行われた変更は、密接に結合された参照型であるため、他のオブジェクトに影響を与えます。構造体のすべてのメンバーはパブリックですが、クラスのすべてのメンバーはプライベートです。 。

構造体の欠点は、継承できないことです。