Sometimes the obviously useful isn’t readily available.
On a recent client project, the code I was writing required me to manipulate many coordinates using CGSize and CGPoint and after a few calculations things were getting bulky.
One of the many features of Apple’s flagship language is the ability to ‘overload’ (basically, rewrite) existing operators (+, -, *, /, etc.). This allows you to redefine their functionality or add compatible operand types (operands being the values you wish to perform the operation on).
In this instance, I was adding multiplication functions to CGSize, CGPoint and CGFloat types and as a result was able to simplify the code nicely throughout the project, for example:
let largeSize = CGSize(width: smallSize.width * factor, height: smallSize.height * factor)
Became this:
let largeSize = smallSize * factor
That may not look like much of a saving, but once you start scaling up (excuse the pun), the improvements in simplicity and readability of your code are noticeable.
Overriding an operator is simple, you just declare your method in the root namespace and it becomes available app-wide.
Let’s look at the following code which provides the operator functionality shown above:
// lhs * rhs = output
func *(lhs: CGSize, rhs: CGFloat) -> CGSize {
return CGSize(width: lhs.width * rhs, height: lhs.height * rhs)
}
With this function defined in the root namespace, every time you use the statement X * Y (where X is of type CGSize and Y is of type CGFloat) a CGSize struct will be returned containing the width and height of X, each multiplied by Y.
This operator is classed as binary because it ‘operates’ on two operands (values). Overloading operators is a very simple process, though I would caution you not to get too carried away, as ambiguity can be easily introduced.
For example:
// lhs - rhs = output
func -(lhs: String, rhs: String) -> String {
return “\(Int(lhs) - Int(rhs))”
}
In this case: “12” - “2” = “10” While valid, this isn’t an obvious use of a String operator and a coder may have expected “Hello World” - “World” to remove one string from the other, resulting in “Hello “ whereas in this case, they would see “0” returned.
If a standard set of operators is too limited for you, Swift allows you to define your own.
Say you want to simplify the process for getting the square root of a number, you could define the square root character √ as an operator, for example:
let result = √144
( pressing ⌥ + v will give you the √ character)
To create a new operator you would first declare it:
prefix operator √
The keyword here is operator, which must be prefixed with either prefix, infix or postfix depending on whether the operand is unary and placed before (prefix) or after (postfix) a single operand, or binary and placed between (infix) two operands.
As before, you define a function that matches the operator declaration:
prefix func √ (number: Double) {
return sqrt(number)
}
This operator is classed as unary because it ‘operates’ on one operand (value).
Operators are so customisable that you can even set the precedence and ordering (remember BODMAS* in school?), but that’s a long story for another post; my purpose here was to provide a brief introduction to the subject.
Hopefully, your interest is sufficiently piqued for you to continue your own exploration of Swift and how it can be tailored to suit your coding needs.
*BODMAS: Brackets, Orders, Division or Multiplication, Addition or Subtraction. An easy mnemonic on the ordering of mathematical calculations, often taught in schools.
Search over 400 blog posts from our team
Subscribe to our monthly digest of blogs to stay in the loop and come with us on our journey to make things better!
We develop intelligent mobile apps for iPhone & Android that deliver for you.
Want to connect? You can find us on Instagram, Facebook, X (formerly Twitter) and LinkedIn.
Here’s our privacy policy.
Here’s our Accessibility statement.
Copyright © 2024 Brightec Limited. All rights reserved.
