Can you explain the differences between struct and class in Swift and when you might choose one over the other?

In depth

Structs in Swift are value types, meaning when they are assigned to a variable or passed to a function, a copy of the original is made. This is beneficial for encapsulating data that should remain independent of the original instance. On the other hand, classes are reference types, so when they are assigned or passed, they share the same instance. This is useful for managing shared state or when you need to leverage inheritance. Another important consideration is performance; structs can be more efficient in certain scenarios due to copy-on-write semantics, which means they only create a copy when they are modified, unlike classes which carry the overhead of reference counting for memory management. Developers should choose based on the intended use case, mutability, and whether or not shared behavior is necessary.

Example scenario

In a project where I developed a data model for a simple ToDo app, I used structs to represent individual tasks since they are lightweight and don’t require inheritance. Each task was independent and could be copied easily when updating the list. However, for a more complex feature involving user sessions where shared state was critical, I opted for a class to ensure that changes in one part of the app reflected across all references to the user session. This distinction between using structs for simple data and classes for shared, mutable state was key to maintaining app performance and clarity.

Common mistakes

One common mistake developers make is using classes when they should use structs, especially for simple data models. This can lead to unnecessary complexity and performance issues, as the overhead of reference counting can slow down the app. Another mistake is misunderstanding the mutability of structs; since they are value types, changes to a struct instance do not affect other instances, which can lead to confusion when a developer expects changes to be reflected across copies.

Follow-up questions

• Can you give an example of a situation where you would prefer a class over a struct?
• How does Swift's memory management differ between classes and structs?
• What are some implications of using value types in concurrent programming?
• Can you explain what happens when you modify a struct inside a function?

Related concepts: inheritance, encapsulation, memory management, copy-on-write, mutability