Structs are value types (copy on assign) in Swift - Step-by-Step Execution

Concept Flow - Structs are value types (copy on assign)

Create struct instance A

↓

Assign A to B (copy)

↓

Modify B

↓

Check A and B values

↓

A unchanged, B changed

When you assign a struct to a new variable, Swift copies the data. Changing the new variable does not affect the original.

Execution Sample

Swift

struct Point {
    var x: Int
    var y: Int
}

var a = Point(x: 1, y: 2)
var b = a
b.x = 10

This code creates a struct Point, copies it from a to b, then changes b.x. a remains unchanged.

Execution Table

Step	Action	Variable	Value of a	Value of b	Note
1	Create a	a	Point(x:1, y:2)	nil	a is initialized
2	Assign a to b (copy)	b	Point(x:1, y:2)	Point(x:1, y:2)	b is a copy of a
3	Modify b.x	b	Point(x:1, y:2)	Point(x:10, y:2)	b changed, a unchanged
4	Check values	a and b	Point(x:1, y:2)	Point(x:10, y:2)	a and b are independent

💡 Execution stops after verifying that modifying b does not affect a

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
a	nil	Point(x:1, y:2)	Point(x:1, y:2)	Point(x:1, y:2)	Point(x:1, y:2)
b	nil	nil	Point(x:1, y:2)	Point(x:10, y:2)	Point(x:10, y:2)

Key Moments - 2 Insights

Why does changing b.x not change a.x?

Because structs are value types, assigning a to b copies the data. So b is a separate copy, and changes to b do not affect a. See execution_table step 3.

Is b a reference to a or a separate copy?

b is a separate copy, not a reference. This is why modifying b does not change a. Refer to execution_table step 2.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of b after step 2?

A Point(x:1, y:2)

B Point(x:10, y:2)

C nil

D Point(x:0, y:0)

💡 Hint

Check the 'Value of b' column at step 2 in the execution_table.

At which step does b.x change to 10?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Action' and 'Value of b' columns in execution_table for when b.x changes.

If structs were reference types, what would happen when b.x changes?

A b would become nil

B a.x would remain 1

C a.x would also change to 10

D a would be deleted

💡 Hint

Think about what happens when two variables point to the same data (reference type).

Concept Snapshot

structs are value types in Swift
Assigning one struct to another copies the data
Modifying the copy does not affect the original
Use structs for independent data copies
This behavior differs from classes (reference types)

Full Transcript

This visual trace shows how structs in Swift behave as value types. When you create a struct instance 'a' and assign it to 'b', Swift copies the data. Changing 'b' later does not affect 'a'. The execution table tracks each step: creating 'a', copying to 'b', modifying 'b', and checking both values. The variable tracker shows 'a' stays the same while 'b' changes. Key moments clarify why changes to 'b' don't affect 'a' because structs copy on assign. The quiz tests understanding of these steps and the difference from reference types. Remember, structs are for independent copies, unlike classes which share references.

Practice

1. What happens when you assign one struct variable to another in Swift?

easy

A. A new copy of the struct data is created.

B. Both variables point to the same data in memory.

C. The original struct is deleted.

D. The struct becomes a class automatically.

Solution

1. Step 1: Understand struct assignment behavior

   Structs in Swift are value types, so assigning one struct to another copies the data.

2. Step 2: Compare with reference types

   Unlike classes, structs do not share references; each variable has its own copy.

3. Final Answer:

   A new copy of the struct data is created. -> Option A

4. Quick Check:

   Struct assignment = copy data [OK]

Hint: Structs copy data on assignment, not references [OK]

Common Mistakes:

• Thinking structs share data like classes
• Assuming assignment links variables
• Confusing structs with reference types

2. Which of the following is the correct way to define a struct in Swift?

easy

A. struct Person = { var name: String }

B. struct Person { var name: String }

C. class Person { var name: String }

D. struct Person() { var name: String }

Solution

1. Step 1: Recall Swift struct syntax

   Structs are defined using the keyword struct followed by the name and braces containing properties.

2. Step 2: Identify correct syntax

   The correct syntax is struct Person { var name: String }. Using = after the name is invalid, using class defines a class instead of a struct, and adding parentheses like Person() is incorrect.

3. Final Answer:

   struct Person { var name: String } -> Option B

4. Quick Check:

   Struct syntax = struct Name { properties } [OK]

Hint: Use 'struct Name { }' to define structs [OK]

Common Mistakes:

• Using class keyword instead of struct
• Adding parentheses after struct name
• Using equals sign in struct definition

3. Consider this Swift code:

struct Point { var x: Int; var y: Int }
var p1 = Point(x: 5, y: 10)
var p2 = p1
p2.x = 20
print(p1.x)

What is the output?

medium

A. 20

B. Compilation error

C. 5

D. 10

Solution

1. Step 1: Understand struct copying on assignment

   Assigning p1 to p2 copies the data, so p2 is a separate copy.

2. Step 2: Analyze mutation effect

   Changing p2.x to 20 does not affect p1.x, which remains 5.

3. Final Answer:

   5 -> Option C

4. Quick Check:

   Struct copy means original unchanged [OK]

Hint: Changing copy doesn't affect original struct [OK]

Common Mistakes:

• Assuming p1.x changes to 20
• Confusing structs with reference types
• Expecting runtime error on assignment

4. This Swift code tries to update a struct inside a function:

struct Counter { var count: Int }
func increment(counter: Counter) {
    var counter = counter
    counter.count += 1
}
var c = Counter(count: 0)
increment(counter: c)
print(c.count)

What is the output and why?

medium

A. 0, because the function modifies a copy, not the original

B. 1, because the function updates the original struct

C. Compilation error due to modifying parameter

D. Runtime error due to immutable struct

Solution

1. Step 1: Understand parameter passing for structs

   Structs are passed by value, so the function receives a copy of c.

2. Step 2: Analyze mutation inside function

   The function modifies its local copy, but c outside remains unchanged.

3. Final Answer:

   0, because the function modifies a copy, not the original -> Option A

4. Quick Check:

   Structs passed by value = original unchanged [OK]

Hint: Structs passed to functions are copies, not originals [OK]

Common Mistakes:

• Expecting original struct to change
• Thinking function parameter is reference
• Assuming compilation or runtime error

5. You want to create a Swift struct that tracks a score and allows updating it inside a method. Which approach correctly updates the struct's property?

hard

A. Use a global variable to hold the struct and update it.

B. Use a non-mutating method and assign a new struct to self.

C. Declare the struct as a class to allow property changes.

D. Use a mutating method inside the struct to change the property.

Solution

1. Step 1: Recall how to modify struct properties

   Structs are value types; to modify properties inside methods, the method must be marked mutating.

2. Step 2: Evaluate options

   Use a mutating method inside the struct to change the property. correctly uses a mutating method. Use a non-mutating method and assign a new struct to self. is incorrect because non-mutating methods cannot change properties. Declare the struct as a class to allow property changes. changes the type to class, which is different. Use a global variable to hold the struct and update it. uses a global variable, which is not ideal.

3. Final Answer:

   Use a mutating method inside the struct to change the property. -> Option D

4. Quick Check:

   Mutating methods update struct properties [OK]

Hint: Mark methods mutating to change struct properties [OK]

Common Mistakes:

• Trying to modify properties in non-mutating methods
• Confusing structs with classes for mutability
• Using global variables instead of methods