strong and weak keywords in Swift

strong and weak keywords in Swift:

In Swift, Strong and weak are keywords used when dealing with reference types (usually classes) to manage memory and prevent strong reference cycles (retain cycles).

1. Strong Reference (strong):

• By default, all references in Swift are strong.
• A strong reference increases the reference count of the object it points to, and the object is deallocated when there are no more strong references to it.
• It implies ownership. An object will not be deallocated as long as there is at least one strong reference to it.

class MyClass {
    // Strong reference to another object
    var anotherObject: AnotherClass?

    init() {
        anotherObject = AnotherClass()
   }
}

2.Weak Reference (weak):

• A weak reference does not increase the reference count of the object it points to.
• It is used to avoid strong reference cycles. If two objects have strong references to each other, they will create a retain cycle, and memory will not be released.
• A weak reference becomes nil automatically when the object it points to is deallocated.

class MyClass {
    // Weak reference to another object
    weak var anotherObject: AnotherClass?

    init() {
        anotherObject = AnotherClass()
    }
}

When to use them:

• Strong references are the default and are suitable in most cases. Use strong references when an object should be kept alive as long as there is at least one strong reference to it.
• Weak references are used to avoid retain cycles, especially in situations where you have a potential ownership cycle. For example, when two objects reference each other, and you want to break the cycle to allow proper deallocation.

class Person {
    var pet: Pet?
}

class Pet {
    weak var owner: Person?
}

In this example, if owner and pet both had strong references to each other, a retain cycle would be created. By using weak for the owner reference in the Pet class, you break the cycle, and each object can be deallocated when it’s no longer needed.