Swift - Operator Overloading

---

---

Operator overloading is used to redefine the behavior of existing operators for custom types.

Operator Overloading in Swift

Operator overloading is a powerful technique in Swift programming. Operator overloading allows us to change the working of the existing operators like +, -, /, *, %, etc. with the customized code.

It allows you to define custom implementations for operators.

Syntax for Overloading an Operator

To overload an operator, we have to define the behaviour of that operator using the "static func" keyword.

Following is the syntax for operator overloading −

 static func operatorSymbol(lhs: Type, rhs: Type) -> ReturnType { // Implementation } 

Consider this example, where we are overloading the addition operator (+) for a Vector type:

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

Types of Operator Overloading

Swift supports overloading operators in three forms:

• Infix Operators: The operators which are placed between two operands.
• Prefix Operators: The operators which are placed before the operands.
• Postfix Operators: The operators which are placed after the operands.

Example of Infix Operator Overloading

Swift program to overload the + operator to add two distances represented in kilometers.

 import Foundation struct Distance { var km: Int static func + (lhs: Distance, rhs: Distance) -> Distance { return Distance(km: lhs.km + rhs.km) } } let morningRun = Distance(km: 5) let eveningRun = Distance(km: 7) let totalDistance = morningRun + eveningRun print("Total distance run: \(totalDistance.km) km") 

Output

 Total distance run: 12 km 

Example of Prefix Operator Overloading

Swift program to overload the prefix -- operator to decrease a vehicle’s fuel level.

 import Foundation prefix operator -- struct FuelTank { var liters: Int static prefix func -- (tank: inout FuelTank) { tank.liters -= 5 } } var myCar = FuelTank(liters: 50) --myCar print("Fuel left in tank: \(myCar.liters) liters") 

Output

 Fuel left in tank: 45 liters 

Example of Postfix Operator Overloading

Swift program to overload a postfix ++ operator to increase a passenger count in an elevator system.

 import Foundation postfix operator ++ struct Elevator { var passengers: Int static postfix func ++ (elevator: inout Elevator) { elevator.passengers += 1 } } var officeLift = Elevator(passengers: 4) officeLift++ print("Current passengers in elevator: \(officeLift.passengers)") 

Output

 Current passengers in elevator: 5 

Operators Overloading More Examples

Practice the following examples to understand the concepts of operators overloading in Swift:

Example 1

Swift program to overload + operator to calculate the sum of two complex numbers.

 import Foundation struct ComplexNumber { var real: Double var imag: Double // Overloading + operator to add two complex numbers static func+(left: ComplexNumber, right: ComplexNumber) -> ComplexNumber { return ComplexNumber(real: left.real + right.real, imag: left.imag + right.imag) } } let complexNumber1 = ComplexNumber(real: 2.1, imag: 2.0) let complexNumber2 = ComplexNumber(real: 6.1, imag: 9.0) // Calling + operator to add two complex numbers let sumOfComplexNumbers = complexNumber1 + complexNumber2 print(sumOfComplexNumbers) 

Output

 ComplexNumber(real: 8.2, imag: 11.0) 

Example 2

Swift program to overload custom prefix operator.

 import Foundation struct Car { var price: Double // Overloading the custom prefix operator "++" to increase the price of car static prefix func ++ (carPrice: inout Car) { carPrice.price += 500000.0 } } var currentPrice = Car(price: 2500000.0) // Calling the custom ++ operator to increase the car price ++currentPrice print("Updated car price is", currentPrice.price) 

Output

 Updated car price is 2500000.0 

Defining a Custom Operator

Swift allows you to create a custom operator where you can define new operators with custom symbols. In this example, we create a custom infix operator ** to perform exponentiation between two integers.

Example

Swift program to define and use a custom ** operator to calculate compound growth like interest or investment value.

 import Foundation // Define custom infix operator for exponentiation infix operator ** : MultiplicationPrecedence func ** (lhs: Int, rhs: Int) -> Int { return Int(pow(Double(lhs), Double(rhs))) } // Calculating future value let baseAmount = 2 let years = 5 let result = baseAmount ** years print("\(baseAmount) raised to the power \(years) is \(result)") 

Output

 2 raised to the power 5 is 32 

Limitation of Operator Overloading

The following are the limitations of operator overloading −

• In Swift, you can overload limited operators like arithmetic and customized operators.
• While overloading operators, you are not allowed to change the precedence or associativity of the operators.
• Swift does not support short-circuiting behaviour for overloading logical operators.
• Do not overuse operator overloading because it makes your code difficult to read and understand.

Difference Between Operator Function and Normal Functions

The following are the major differences between the operator functions and normal functions −