{"id":2748,"date":"2026-02-05T12:13:44","date_gmt":"2026-02-05T12:13:44","guid":{"rendered":"https:\/\/demo.materiamedica.net\/demo6\/?p=2748"},"modified":"2026-02-05T12:13:44","modified_gmt":"2026-02-05T12:13:44","slug":"chapter-81-swift-class-vs-struct","status":"publish","type":"post","link":"https:\/\/demo.materiamedica.net\/demo6\/chapter-81-swift-class-vs-struct\/","title":{"rendered":"Chapter 81: Swift Class vs Struct"},"content":{"rendered":"

Class vs Struct in Swift<\/strong> \u2014 written exactly like a patient, experienced teacher sitting next to you with a playground open.<\/p>\n

We are going to go very slowly<\/strong>, with many small examples<\/strong>, real-life analogies, real-world decision patterns, common beginner mistakes, and the modern mental model that most good Swift developers use every day in 2025\u20132026.<\/p>\n

Let\u2019s start from the very beginning.<\/p>\n

1. The Core Difference \u2014 Value Type vs Reference Type<\/h3>\n

This is the single most important thing<\/strong> to understand. Everything else follows from this.<\/p>\n

\n
\n\n\n\n\n\n\n\n\n\n\n\n\n
Property<\/th>\nStruct<\/strong> (Value Type)<\/th>\nClass<\/strong> (Reference Type)<\/th>\nReal-life analogy<\/th>\n<\/tr>\n<\/thead>\n
What is assigned \/ passed<\/td>\nFull copy<\/strong> of all data<\/td>\nReference<\/strong> (pointer) to the same object<\/td>\nGiving a photocopy vs giving the original photo<\/td>\n<\/tr>\n
Changing one variable affects others?<\/td>\nNo<\/strong> \u2014 each copy is independent<\/td>\nYes<\/strong> \u2014 all variables point to the same object<\/td>\nChanging one photocopy doesn\u2019t change others<\/td>\n<\/tr>\n
Identity comparison (===)<\/td>\nNot possible<\/strong> (value types don\u2019t have identity)<\/td>\nPossible<\/strong> \u2014 checks if same instance in memory<\/td>\nAsking \u201care these two the exact same photo print?\u201d<\/td>\n<\/tr>\n
Memory management<\/td>\nCopied on write (Copy-on-Write for Array\/Dict\/String)<\/td>\nReference counting (ARC)<\/td>\nCopies take more memory only when actually changed<\/td>\n<\/tr>\n
Thread safety (mutable shared state)<\/td>\nSafer \u2014 copies are independent<\/td>\nDangerous \u2014 needs careful synchronization<\/td>\nCopies are safe to modify from multiple threads<\/td>\n<\/tr>\n
Performance (small data)<\/td>\nUsually faster (stack allocation possible)<\/td>\nUsually slower (heap + reference counting)<\/td>\nSmall copies are cheap<\/td>\n<\/tr>\n
Can inherit<\/td>\nNo<\/strong><\/td>\nYes<\/strong> (single inheritance)<\/td>\nClasses can have parents<\/td>\n<\/tr>\n
Can be used as Dictionary key<\/td>\nYes<\/strong> (if Hashable)<\/td>\nYes<\/strong> (but need careful Hashable)<\/td>\nStructs are easier for keys<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
<\/div>\n<\/div>\n<\/div>\n

Golden rule used by almost every experienced Swift developer today<\/strong>:<\/p>\n

\n

Default to struct for almost everything.<\/strong> Use class only when you really need one of these things:<\/strong><\/p>\n

    \n
  • reference semantics (shared mutable state)<\/li>\n
  • inheritance<\/li>\n
  • Objective-C interop \/ UIKit compatibility<\/li>\n
  • identity comparison (===)<\/li>\n<\/ul>\n<\/blockquote>\n

    2. Side-by-side comparison with real examples<\/h3>\n

    Example 1 \u2013 Mutability & copying<\/h4>\n
    \n
    \n
    \n
    Swift<\/div>\n
    \n
    \/\/ Struct \u2014 value type\r\nstruct Point {\r\n    var x: Int\r\n    var y: Int\r\n}\r\n\r\nvar p1 = Point(x: 10, y: 20)\r\nvar p2 = p1                \/\/ \u2190 full copy\r\n\r\np2.x = 100\r\n\r\nprint(p1.x)                \/\/ 10  \u2014 unchanged\r\nprint(p2.x)                \/\/ 100 \u2014 only p2 changed<\/code><\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    \n
    \n
    \n
    Swift<\/div>\n
    \n
    \/\/ Class \u2014 reference type\r\nclass ReferencePoint {\r\n    var x: Int\r\n    var y: Int\r\n    \r\n    init(x: Int, y: Int) {\r\n        self.x = x\r\n        self.y = y\r\n    }\r\n}\r\n\r\nlet rp1 = ReferencePoint(x: 10, y: 20)\r\nlet rp2 = rp1              \/\/ \u2190 same object, just another reference\r\n\r\nrp2.x = 100\r\n\r\nprint(rp1.x)               \/\/ 100 \u2014 changed!\r\nprint(rp2.x)               \/\/ 100 \u2014 same object\r\nprint(rp1 === rp2)         \/\/ true \u2014 same instance<\/code><\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    Key takeaway<\/strong>:<\/p>\n
      \n
    • Struct<\/strong> \u2192 changing one copy never<\/strong> affects others<\/li>\n
    • Class<\/strong> \u2192 changing through any reference affects all references<\/strong><\/li>\n<\/ul>\n
      3. Real-life examples \u2014 when developers choose struct vs class<\/h3>\n
      Example 1 \u2013 Data model (almost always struct)<\/h4>\n
      \n
      \n
      \n
      Swift<\/div>\n
      \n
      struct Product {\r\n    let id: String\r\n    let name: String\r\n    let price: Decimal\r\n    var quantity: Int = 1\r\n    \r\n    var subtotal: Decimal {\r\n        price * Decimal(quantity)\r\n    }\r\n    \r\n    mutating func increase(by step: Int = 1) {\r\n        quantity += step\r\n    }\r\n}\r\n\r\nvar cart: [Product] = []\r\ncart.append(Product(id: \"P001\", name: \"Earbuds\", price: 3499))\r\n\r\n\/\/ Copying is safe\r\nvar backupCart = cart\r\nbackupCart[0].increase(by: 2)\r\n\r\nprint(cart[0].quantity)      \/\/ still 1 \u2014 safe!\r\nprint(backupCart[0].quantity) \/\/ 3<\/code><\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
      Why struct here?<\/strong><\/p>\n
        \n
      • No shared mutable state needed<\/li>\n
      • Copying is cheap (Copy-on-Write for Array)<\/li>\n
      • Value semantics \u2014 very predictable & safe<\/li>\n<\/ul>\n
        Example 2 \u2013 ViewController \/ view model (often class)<\/h4>\n
        \n
        \n
        \n
        Swift<\/div>\n
        \n
        class CartViewModel: ObservableObject {\r\n    @Published var items: [CartItem] = []\r\n    @Published var total: Decimal = 0\r\n    \r\n    func addItem(_ item: CartItem) {\r\n        items.append(item)\r\n        updateTotal()\r\n    }\r\n    \r\n    private func updateTotal() {\r\n        total = items.reduce(0) { $0 + $1.subtotal }\r\n    }\r\n}<\/code><\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
        Why class here?<\/strong><\/p>\n
          \n
        • Needs to be shared<\/strong> between views (@ObservedObject, @StateObject)<\/li>\n
        • Identity matters (same view model instance)<\/li>\n
        • Needs to notify observers<\/strong> when data changes (@Published)<\/li>\n<\/ul>\n
          3. When to choose struct vs class \u2014 decision checklist<\/h3>\n
          \n
          \n\n\n\n\n\n\n\n\n\n\n\n
          Question \/ Need<\/th>\nChoose Struct<\/th>\nChoose Class<\/th>\nTypical real-world decision<\/th>\n<\/tr>\n<\/thead>\n
          Do you need identity<\/strong> (===)?<\/td>\nNo<\/td>\nYes<\/td>\nShared state, view models<\/td>\n<\/tr>\n
          Do you need inheritance<\/strong>?<\/td>\nNo<\/td>\nYes<\/td>\nUIKit\/AppKit view controllers<\/td>\n<\/tr>\n
          Do you want value semantics<\/strong> (copy = independent)?<\/td>\nYes<\/td>\nNo<\/td>\nData models, DTOs, value objects<\/td>\n<\/tr>\n
          Is thread-safety important (mutable shared state)?<\/td>\nYes (safer)<\/td>\nNo (needs careful synchronization)<\/td>\nModern apps prefer struct<\/td>\n<\/tr>\n
          Is the data small<\/strong> & frequently copied<\/strong>?<\/td>\nYes (Copy-on-Write efficient)<\/td>\nNo (reference counting overhead)<\/td>\nAlmost always struct<\/td>\n<\/tr>\n
          Do you need Objective-C interop?<\/td>\nNo<\/td>\nYes<\/td>\nUIKit, Core Data, etc.<\/td>\n<\/tr>\n
          Are you using SwiftUI \/ Combine heavily?<\/td>\nYes (structs + @State \/ @Binding)<\/td>\nSometimes (ObservableObject class)<\/td>\nStructs for most data<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
          <\/div>\n<\/div>\n<\/div>\n
          Modern Swift recommendation (2025\u20132026)<\/strong>:<\/p>\n
          \n
          Default to struct for almost everything<\/strong> Use class<\/strong> only when you really need<\/strong>:<\/p>\n
            \n
          • reference semantics (shared mutable state)<\/li>\n
          • inheritance<\/li>\n
          • Objective-C compatibility<\/li>\n
          • identity comparison (===)<\/li>\n<\/ul>\n<\/blockquote>\n
            4. Very Common Beginner Mistakes & Correct Habits<\/h3>\n
            \n
            \n\n\n\n\n\n\n\n\n\n
            Mistake<\/th>\nWrong \/ Risky code<\/th>\nCorrect \/ Better habit<\/th>\nWhy?<\/th>\n<\/tr>\n<\/thead>\n
            Using class by default \u201cjust in case\u201d<\/td>\nclass User { \u2026 } everywhere<\/td>\nDefault to struct unless you need reference semantics<\/td>\nValue types are safer & more predictable<\/td>\n<\/tr>\n
            Force-unwrapping in class\/struct<\/td>\nself.user!.name<\/td>\nguard let user = user else { \u2026 }<\/td>\nPrevents crashes<\/td>\n<\/tr>\n
            Deep class inheritance<\/td>\n5+ levels of class inheritance<\/td>\nPrefer composition or protocols<\/td>\nDeep hierarchies become hard to reason about<\/td>\n<\/tr>\n
            Forgetting mutating in struct methods<\/td>\nfunc increaseAge() { age += 1 }<\/td>\nmutating func increaseAge() { age += 1 }<\/td>\nCompile error if missing<\/td>\n<\/tr>\n
            Sharing mutable class state without care<\/td>\nstatic let shared = MyManager()<\/td>\nPrefer dependency injection over singletons<\/td>\nSingletons make testing & reasoning hard<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
            <\/div>\n<\/div>\n<\/div>\n
            5. Small Practice \u2014 Try these<\/h3>\n
              \n
            1. Create a Personstruct<\/strong> with:\n
                \n
              • let name: String<\/li>\n
              • var age: Int<\/li>\n
              • mutating func haveBirthday()<\/li>\n<\/ul>\n<\/li>\n
              • Create a BankAccountstruct<\/strong> like the example above\n
                  \n
                • private var balance: Double<\/li>\n
                • init(initialDeposit:)<\/li>\n
                • mutating func deposit(amount:)<\/li>\n
                • mutating func withdraw(amount:) -> Bool<\/li>\n<\/ul>\n<\/li>\n
                • Create a Locationstruct<\/strong>\n
                    \n
                  • let latitude: Double, longitude: Double<\/li>\n
                  • var name: String?<\/li>\n
                  • computed property coordinateString<\/li>\n<\/ul>\n<\/li>\n<\/ol>\n
                    Paste your code here if you want feedback or want to see more polished versions!<\/p>\n
                    What would you like to explore next?<\/p>\n
                      \n
                    • Struct vs Class<\/strong> \u2014 detailed comparison & decision guide<\/li>\n
                    • Mutability<\/strong> inside structs (mutating methods)<\/li>\n
                    • Struct initializers<\/strong> (default, custom, memberwise)<\/li>\n
                    • Structs in SwiftUI<\/strong> (@State, value types, performance)<\/li>\n
                    • Or move to another topic (optionals, arrays, closures, switch\u2026)<\/li>\n<\/ul>\n
                      Just tell me \u2014 we\u2019ll continue in the same clear, detailed, patient style \ud83d\ude0a<\/p>\n","protected":false},"excerpt":{"rendered":"
                      Class vs Struct in Swift \u2014 written exactly like a patient, experienced teacher sitting next to you with a playground open. We are going to go very slowly, with many small examples, real-life analogies,...<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[76],"tags":[],"class_list":["post-2748","post","type-post","status-publish","format-standard","hentry","category-swift"],"_links":{"self":[{"href":"https:\/\/demo.materiamedica.net\/demo6\/wp-json\/wp\/v2\/posts\/2748","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/demo.materiamedica.net\/demo6\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/demo.materiamedica.net\/demo6\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/demo.materiamedica.net\/demo6\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/demo.materiamedica.net\/demo6\/wp-json\/wp\/v2\/comments?post=2748"}],"version-history":[{"count":1,"href":"https:\/\/demo.materiamedica.net\/demo6\/wp-json\/wp\/v2\/posts\/2748\/revisions"}],"predecessor-version":[{"id":2749,"href":"https:\/\/demo.materiamedica.net\/demo6\/wp-json\/wp\/v2\/posts\/2748\/revisions\/2749"}],"wp:attachment":[{"href":"https:\/\/demo.materiamedica.net\/demo6\/wp-json\/wp\/v2\/media?parent=2748"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/demo.materiamedica.net\/demo6\/wp-json\/wp\/v2\/categories?post=2748"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/demo.materiamedica.net\/demo6\/wp-json\/wp\/v2\/tags?post=2748"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}