Operator overloading concept in Swift - Time & Space Complexity

Time Complexity: Operator overloading concept

O(n)

Understanding Time Complexity

When we use operator overloading, we create custom ways to use operators like + or * with our own types.

We want to see how the time it takes to run changes as the input size grows.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

struct Vector {
  var values: [Double]

  static func + (left: Vector, right: Vector) -> Vector {
    var result = [Double]()
    for i in 0..

This code defines how to add two Vector objects by adding their elements one by one.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: A for-loop that adds each pair of elements from two arrays.
• How many times: The loop runs once for each element in the vectors, so as many times as the vector length.

How Execution Grows With Input

Explain the growth pattern intuitively.

Input Size (n)	Approx. Operations
10	About 10 additions
100	About 100 additions
1000	About 1000 additions

Pattern observation: The number of operations grows directly with the size of the vectors. Double the size, double the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to add two vectors grows in a straight line with the number of elements.

Common Mistake

[X] Wrong: "Operator overloading makes the operation instant or constant time."

[OK] Correct: Even though the operator looks simple, it still does work for each element, so time grows with input size.

Interview Connect

Understanding how operator overloading affects performance helps you explain your code clearly and shows you think about efficiency.

Self-Check

"What if we changed the Vector to store a fixed number of elements instead of an array? How would the time complexity change?"

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