Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
Swift · Question Set
Structs, Classes & Value vs Reference Types interview questions for placements and exams.
Questions
11
Included in this set
Subject
Swift
Explore more sets
Difficulty
Mixed
Level of this set
Go through each question and its explanation. Use this set as a focused practice pack for Swift.
Apple's documentation recommends using structures by default, and choosing classes only when you need features that structs don't provide (such as identity, inheritance or Objective-C interoperability). This guideline promotes safer, simpler code.
For complete preparation, combine this set with full subject-wise practice for Swift. You can also explore other subjects and sets from the links below.
Value semantics (structs) mean each instance holds its own copy of data, so modifying one does not affect others. Reference semantics (classes) mean multiple variables can refer to the same instance, so changes via one reference affect all. Recognizing this difference is key to correct design.
When choosing between struct and class in Swift, you consider semantics, performance, mutability and design intent. /n/n Use a `struct` when you want value-type semantics: the data is relatively simple, you don't need inheritance, identity, shared mutable state or Objective-C interop. Structs provide safer copying, fewer memory pitfalls and often better performance. /n/n Use a `class` when you need reference semantics: when instances need identity (two references should refer to the same object), when you need inheritance, or when interoperation with Objective-C APIs is required. You also consider memory impact: classes use ARC and reference counting overhead. Apple recommends using struct by default and classes only when necessary.
In Swift, structs are value types. This means when you assign a struct instance to a new variable or pass it to a function, a copy is created. Thus changes in the new instance do not affect the original. This behaviour enhances safety and predictability for small-data models.
In Swift, classes are reference types — assigning a class instance to a new variable passes a reference, not a copy. The language uses Automatic Reference Counting (ARC) to manage memory for class instances.
In Swift, structs do not support inheritance from other types (they can conform to protocols, but cannot subclass). Classes support inheritance. This limitation influences when you choose classes vs structs.
In Swift a `struct` is a value type. To modify its own properties within a method, you must mark the method `mutating`. This makes clear that the instance is being changed. Classes do not require `mutating`.
The `===` operator in Swift checks whether two references point to the **exact same instance** of a class (identity check), whereas `==` checks for equality of value (if implemented). This is only relevant for reference types (classes).
Many Swift value types (e.g., Array, Dictionary) use Copy on Write (COW) under the hood: multiple variables may share storage until a mutation forces duplication, improving performance while preserving value semantics. This detail is often asked in interviews.
Consider the code: `struct Point { var x: Int; var y: Int } var p1 = Point(x:0, y:0); var p2 = p1; p2.x = 10; // p1.x still 0` and `class Node { var value: Int; init(_ value:Int) { self.value = value } } var n1 = Node(5); var n2 = n1; n2.value = 10; // n1.value now 10` /n/n This example shows that struct assignment creates an independent copy, class assignment shares a reference. In multi-threaded or shared state use‐cases, value semantics help avoid unintended side-effects and race conditions because each thread works on its own copy; reference types need careful synchronization when shared. Choosing correctly affects thread safety, performance and design clarity.
In Swift, classes are reference types and use Automatic Reference Counting (ARC) to manage memory: each time you create a reference the count increments, and when references drop to zero the instance is deallocated. This means misuse (e.g., strong reference cycles) can cause memory leaks. Structs are value types and don't use ARC; copying creates independent instances and memory is managed more simply. /n/n From a performance perspective, structs often have less overhead (no reference counting, fewer indirections) and may be allocated on the stack or optimized by the compiler. However, if a struct is large and copied often, the overhead can be higher. Understanding these trade-offs is important in interview discussions.