What is the difference between struct and class in Swift?

Question

IT Interview Practice · Accepted Answer

A `struct` is a **value type**: it is copied on assignment, and each copy is independent. A `class` is a **reference type**: assignment shares one instance, and both variables point to the same object. This single difference drives most design decisions in Swift.

## How it works

```swift
struct PointS { var x: Int }
class  PointC { var x: Int; init(x: Int) { self.x = x } }

var a = PointS(x: 1)
var b = a          // COPY — b is a separate struct
b.x = 99
print(a.x, b.x)    // => 1 99  (a unaffected)

let c = PointC(x: 1)
let d = c          // SHARE — same instance
d.x = 99
print(c.x, d.x)    // => 99 99 (both changed)
```

## Trade-offs

| Aspect | struct (value) | class (reference) |
|--------|----------------|-------------------|
| Copy semantics | independent copy | shared reference |
| Mutation | needs `var` / `mutating` | mutable via any reference |
| Identity | none (compare by value) | `===` identity |
| Inheritance | no | yes |
| Memory | usually stack, no ARC | heap, ARC-managed |

Structs also need `mutating` to change stored properties in a method, because methods get an immutable `self` by default.

## When to use which

- **Default to `struct`** — Swift's standard library (`Array`, `String`, `Int`) and SwiftUI `View`s are all value types. They are safe to share across threads and have no retain cycles.
- Use `class` when you need **shared mutable state**, **identity**, **inheritance**, or Objective-C interop (`NSObject`).

## Why it matters

Choosing value vs reference decides whether a change in one place leaks into another. Bugs where "editing one item edited them all" come from unexpected reference sharing; SwiftUI's whole model assumes cheap, copyable value-type views — so interviewers check that you reach for `struct` first.

Aspect	struct (value)	class (reference)
Copy semantics	independent copy	shared reference
Mutation	needs `var` / `mutating`	mutable via any reference
Identity	none (compare by value)	`===` identity
Inheritance	no	yes
Memory	usually stack, no ARC	heap, ARC-managed

How it works

Trade-offs

When to use which

Why it matters

Related questions