Swift Refs: Strong, Weak, and Unowned – What You Need to Know

By /

Swift Refs: Strong, Weak, and Unowned – What You Need to Know

Swift is a powerful and intuitive programming language for macOS, iOS, watchOS, tvOS, and beyond. It’s designed to give developers the freedom to create amazing apps and games in a safe and secure environment. With Swift, you can easily take advantage of the latest technologies to develop high-performance apps and games.

One of the most important concepts in Swift is references. References are used to refer to objects in memory. Swift provides three types of references: strong, weak, and unowned. In this blog post, we’ll take a look at each type of reference and explain how they work.

Strong References

Strong references are the most common type of reference in Swift. A strong reference keeps a strong hold on the object it refers to, and the object will not be deallocated as long as at least one strong reference exists.

Let’s take a look at an example. Consider the following code:

let viewController = UIViewController() 
let view = UIView(frame: viewController.view.bounds) 
viewController.view.addSubview(view)

In this code, we’re creating a UIViewController and then adding a UIView as a subview. The viewController variable is a strong reference to the UIViewController object, and the view variable is a strong reference to the UIView object. As long as these references exist, the objects will not be deallocated.

Weak References

Weak references are different from strong references in that they do not keep a strong hold on the object they refer to. If there are no other strong references to the object, it will be deallocated.

Weak references are useful for avoiding reference cycles. A reference cycle occurs when two or more objects have strong references to each other, which prevents them from being deallocated.

Consider the following code:

class Parent { 
  var child: Child? 
} 
 
class Child { 
  var parent: Parent? 
}

In this code, we’re defining a Parent and Child class. The Parent class has a strong reference to a Child object, and the Child class has a strong reference to a Parent object. This creates a reference cycle, and neither object will be deallocated.

To solve this problem, we can use a weak reference. We can modify the code as follows:

class Parent { 
  weak var child: Child? 
} 
 
class Child { 
  weak var parent: Parent? 
}

Now, the Parent and Child classes have weak references to each other. This prevents the reference cycle, and the objects can now be deallocated.

Unowned References

Unowned references are similar to weak references in that they do not keep a strong hold on the object they refer to. However, unlike weak references, unowned references are not set to nil when the object is deallocated.

Unowned references are useful when the object they refer to will never be deallocated. For example, consider the following code:

class Person { 
  let name: String 
  let address: Address 
 
  init(name: String, address: Address) { 
    self.name = name 
    self.address = address 
  } 
} 
 
class Address { 
  let street: String 
  let city: String 
  let person: Person 
 
  init(street: String, city: String, person: Person) { 
    self.street = street 
    self.city = city 
    self.person = person 
  } 
}

In this code, we’re defining a Person and Address class. The Person class has a strong reference to an Address object, and the Address class has a strong reference to a Person object. This creates a reference cycle, and neither object will be deallocated.

To solve this problem, we can use an unowned reference. We can modify the code as follows:

class Person { 
  let name: String 
  let address: Address 
 
  init(name: String, address: Address) { 
    self.name = name 
    self.address = address 
  } 
} 
 
class Address { 
  let street: String 
  let city: String 
  unowned let person: Person 
 
  init(street: String, city: String, person: Person) { 
    self.street = street 
    self.city = city 
    self.person = person 
  } 
}

Now, the Person and Address classes have unowned references to each other. This prevents the reference cycle, and the objects can now be deallocated.

In summary, strong, weak, and unowned references are an important concept in Swift. They provide a way to refer to objects in memory and prevent reference cycles. Understanding how they work is essential for developing robust and efficient applications in Swift.

Scroll to Top