Operator overloading concept in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to overload the + operator for the Vector struct.

Swift

struct Vector {
    var x: Int
    var y: Int

    static func + (lhs: Vector, rhs: Vector) -> Vector {
        return Vector(x: lhs.x [1] rhs.x, y: lhs.y + rhs.y)
    }
}

Drag options to blanks, or click blank then click option'

A*

B-

C+

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using - instead of + for addition.

Forgetting to make the function static.

Not returning a new Vector instance.

The + operator is overloaded by defining a static function named + that takes two Vectors and returns their sum.

2fill in blank

medium

Complete the code to overload the == operator to compare two Vector instances.

Swift

struct Vector {
    var x: Int
    var y: Int

    static func == (lhs: Vector, rhs: Vector) -> Bool {
        return lhs.x [1] rhs.x && lhs.y == rhs.y
    }
}

Drag options to blanks, or click blank then click option'

A!=

B==

C>

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using != instead of ==.

Comparing only one coordinate.

Not returning a Bool value.

The == operator checks if both x and y values of two Vectors are equal.

3fill in blank

hard

Fix the error in the operator overloading function to multiply a Vector by an integer scalar.

Swift

struct Vector {
    var x: Int
    var y: Int

    static func * (vector: Vector, scalar: Int) -> Vector {
        return Vector(x: vector.x [1] scalar, y: vector.y * scalar)
    }
}

Drag options to blanks, or click blank then click option'

A+

B-

C/

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Using + or - instead of *.

Multiplying only one coordinate.

Returning the wrong type.

The * operator multiplies each coordinate of the Vector by the scalar value.

4fill in blank

hard

Fill both blanks to overload the - operator to subtract two Vector instances.

Swift

struct Vector {
    var x: Int
    var y: Int

    static func - (lhs: Vector, rhs: Vector) -> Vector {
        return Vector(x: lhs.x [1] rhs.x, y: lhs.y [2] rhs.y)
    }
}

Drag options to blanks, or click blank then click option'

A-

B+

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using + instead of -.

Mixing operators between x and y.

Returning incorrect Vector values.

The - operator subtracts the x and y values of rhs from lhs to get the difference Vector.

5fill in blank

hard

Fill all three blanks to overload the += operator for Vector addition and assignment.

Swift

struct Vector {
    var x: Int
    var y: Int

    static func += (lhs: inout Vector, rhs: Vector) {
        lhs.x [1]= rhs.x
        lhs.y [2]= rhs.y
    }

    static func + (lhs: Vector, rhs: Vector) -> Vector {
        return Vector(x: lhs.x [3] rhs.x, y: lhs.y + rhs.y)
    }
}

Drag options to blanks, or click blank then click option'

A+

B-

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using -= or other operators instead of +=.

Forgetting to mark lhs as inout.

Mixing operators in the + function.

The += operator adds rhs's x and y to lhs's x and y respectively. The + operator returns a new Vector with summed coordinates.

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