Operator overloading concept in Swift - Step-by-Step Execution

Concept Flow - Operator overloading concept

Define operator function

↓

Use operator with custom type

↓

Swift calls overloaded operator

↓

Execute custom logic

↓

Return result

↓

Use result in code

Operator overloading lets you define how operators like + or * work with your own types. When you use the operator, Swift runs your custom code.

Execution Sample

Swift

struct Point {
  var x: Int
  var y: Int
  static func + (lhs: Point, rhs: Point) -> Point {
    return Point(x: lhs.x + rhs.x, y: lhs.y + rhs.y)
  }
}

Defines how to add two Point values by adding their x and y parts.

Execution Table

Step	Action	lhs (Point)	rhs (Point)	Operation	Result (Point)
1	Call + operator with p1 and p2	Point(x: 2, y: 3)	Point(x: 4, y: 5)	Add x and y separately	Point(x: 6, y: 8)
2	Return new Point from + operator	Point(x: 2, y: 3)	Point(x: 4, y: 5)	Create Point(x: 6, y: 8)	Point(x: 6, y: 8)
3	Use result in code	N/A	N/A	Assign or print	Point(x: 6, y: 8)
4	End	N/A	N/A	No more operations	Execution stops

💡 Operator function completes and returns the new Point, ending execution.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
p1	Point(x: 2, y: 3)	Point(x: 2, y: 3)	Point(x: 2, y: 3)	Point(x: 2, y: 3)
p2	Point(x: 4, y: 5)	Point(x: 4, y: 5)	Point(x: 4, y: 5)	Point(x: 4, y: 5)
result	N/A	N/A	Point(x: 6, y: 8)	Point(x: 6, y: 8)

Key Moments - 3 Insights

Why does the + operator work with Point even though Point is not a built-in type?

Because we defined a static function + inside Point that tells Swift how to add two Points (see execution_table step 1).

What happens if we forget to return a new Point in the + function?

The code won't compile because the operator function must return a Point, as shown in execution_table step 2.

Does the original Point values change after using +?

No, p1 and p2 stay the same; the + operator creates and returns a new Point (see variable_tracker).

Visual Quiz - 3 Questions

Look at the execution_table, what is the result of adding Point(x: 2, y: 3) and Point(x: 4, y: 5) at step 1?

A Point(x: 6, y: 8)

B Point(x: 8, y: 15)

C Point(x: 2, y: 3)

D Point(x: 4, y: 5)

💡 Hint

Check the 'Result (Point)' column in execution_table row 1.

According to variable_tracker, what is the value of 'result' after step 2?

A Point(x: 2, y: 3)

B Point(x: 6, y: 8)

C Point(x: 4, y: 5)

D N/A

💡 Hint

Look at the 'result' row under 'After Step 2' in variable_tracker.

If we change the + function to subtract x and y instead, how would the result at step 1 change?

A Point(x: 2, y: 3)

B Point(x: 6, y: 8)

C Point(x: -2, y: -2)

D Point(x: 4, y: 5)

💡 Hint

Think about subtracting lhs.x - rhs.x and lhs.y - rhs.y instead of adding.

Concept Snapshot

Operator Overloading in Swift:
- Define static func with operator symbol inside your type.
- Function takes operands and returns result.
- Allows using operators like + with custom types.
- Original values stay unchanged; new value returned.
- Enables clean, readable code for custom operations.

Full Transcript

Operator overloading lets you define how operators like plus (+) work with your own types in Swift. You write a static function named with the operator symbol inside your type, for example, Point. This function takes two Points as input and returns a new Point as the result. When you use the + operator with Points, Swift calls your function, runs your custom code to add the x and y parts, and returns a new Point. The original Points do not change. This makes your code easy to read and use with your custom types.

Practice

1. What does operator overloading allow you to do in Swift?

easy

A. Change the behavior of built-in operators globally

B. Define how operators work with your own custom types

C. Create new operators that don't exist in Swift

D. Prevent operators from being used with certain types

Solution

1. Step 1: Understand operator overloading purpose

   Operator overloading lets you specify how operators like +, -, * behave with your own types, such as structs or classes.

2. Step 2: Eliminate incorrect options

   It does not change built-in operators globally, create new operators, or prevent usage; it only defines behavior for your types.

3. Final Answer:

   Define how operators work with your own custom types -> Option B

4. Quick Check:

   Operator overloading = custom operator behavior [OK]

Hint: Operator overloading customizes operators for your types [OK]

Common Mistakes:

• Thinking it changes operators globally
• Confusing overloading with creating new operators
• Believing it disables operators for types

2. Which of the following is the correct way to overload the + operator for a struct named Vector in Swift?

easy

A. static func + (lhs: Vector, rhs: Vector) -> Vector { ... }

B. operator func + (lhs: Vector, rhs: Vector) -> Vector { ... }

C. func + (lhs: Vector, rhs: Vector) -> Vector { ... }

D. func + (Vector lhs, Vector rhs) -> Vector { ... }

Solution

1. Step 1: Recall Swift operator overloading syntax

   In Swift, operator overloads inside a type must be declared as static functions.

2. Step 2: Check each option

   static func + (lhs: Vector, rhs: Vector) -> Vector { ... } uses 'static func' correctly. func + (lhs: Vector, rhs: Vector) -> Vector { ... } misses 'static'. operator func + (lhs: Vector, rhs: Vector) -> Vector { ... } uses invalid 'operator func'. func + (Vector lhs, Vector rhs) -> Vector { ... } uses wrong parameter syntax.

3. Final Answer:

   static func + (lhs: Vector, rhs: Vector) -> Vector { ... } -> Option A

4. Quick Check:

   Operator overload = static func inside type [OK]

Hint: Use 'static func' inside type to overload operators [OK]

Common Mistakes:

• Omitting 'static' keyword
• Using invalid keywords like 'operator func'
• Wrong parameter syntax

3. Given the following code, what is the output?

struct Point {
    var x: Int
    var y: Int
    static func + (lhs: Point, rhs: Point) -> Point {
        Point(x: lhs.x + rhs.x, y: lhs.y + rhs.y)
    }
}

let p1 = Point(x: 2, y: 3)
let p2 = Point(x: 4, y: 1)
let p3 = p1 + p2
print("(\(p3.x), \(p3.y))")

medium

A. Compilation error

B. (2, 3)

C. (4, 1)

D. (6, 4)

Solution

1. Step 1: Understand operator + implementation

   The + operator adds the x and y values of two Point instances and returns a new Point.

2. Step 2: Calculate the result of p1 + p2

   p1.x + p2.x = 2 + 4 = 6, p1.y + p2.y = 3 + 1 = 4, so p3 is Point(x: 6, y: 4).

3. Final Answer:

   (6, 4) -> Option D

4. Quick Check:

   Sum of coordinates = (6, 4) [OK]

Hint: Add x and y separately for Point + Point [OK]

Common Mistakes:

• Confusing which values to add
• Expecting original points to print
• Thinking operator overload causes error

4. Identify the error in this operator overload code for a struct Number:

struct Number {
    var value: Int
    func + (lhs: Number, rhs: Number) -> Number {
        Number(value: lhs.value + rhs.value)
    }
}

medium

A. The function should be static

B. The function should return Int, not Number

C. The parameters should be of type Int, not Number

D. The function should be outside the struct

Solution

1. Step 1: Check operator overload function declaration

   Operator overloads inside a struct must be declared as static functions.

2. Step 2: Verify other parts

   Return type Number is correct, parameters are correct, and function should be inside the struct.

3. Final Answer:

   The function should be static -> Option A

4. Quick Check:

   Operator overload must be static func [OK]

Hint: Operator overloads inside types must be static [OK]

Common Mistakes:

• Forgetting 'static' keyword
• Changing return type incorrectly
• Moving function outside struct

5. You want to overload the * operator to multiply a Matrix by an Int scalar in Swift. Which of these is the correct way to declare this operator overload inside the Matrix struct?

hard

A. static func * (lhs: Matrix, rhs: Matrix) -> Matrix { ... }

B. func * (lhs: Matrix, rhs: Int) -> Matrix { ... }

C. static func * (lhs: Matrix, rhs: Int) -> Matrix { ... }

D. static func * (lhs: Int, rhs: Matrix) -> Matrix { ... }

Solution

1. Step 1: Understand operator overload for scalar multiplication

   Multiplying a Matrix by an Int scalar means lhs is Matrix, rhs is Int, returning a Matrix.

2. Step 2: Check function declaration rules

   Inside Matrix struct, operator overload must be static func with parameters (Matrix, Int) and return Matrix.

3. Final Answer:

   static func * (lhs: Matrix, rhs: Int) -> Matrix { ... } -> Option C

4. Quick Check:

   Matrix * Int overload = static func with (Matrix, Int) [OK]

Hint: Match parameter types and use static func inside struct [OK]

Common Mistakes:

• Omitting static keyword
• Swapping parameter order incorrectly
• Using wrong parameter types