Can you explain how the reference counting mechanism works in memory management systems?

The reference counting mechanism is a method of memory management where each object has a reference counter indicating how many active references exist to that object.

When a new strong reference to an object is created, the counter increases by 1. When a reference is no longer used (for example, a variable goes out of scope or is assigned to another object), the counter decreases by 1. If the counter reaches zero, it means no references point to the object, and its memory can be freed.

In iOS, for example, ARC (Automatic Reference Counting) automatically inserts operations to increase and decrease the reference counter in the code, relieving the programmer from manual memory management.

Example in Swift:

class Person {
    var name: String
    init(name: String) {
        self.name = name
        print("Person \(name) created")
    }
    deinit {
        print("Person \(name) destroyed")
    }
}

var p1: Person? = Person(name: "Ivan") // counter = 1
var p2 = p1 // counter = 2
p1 = nil // counter = 1
p2 = nil // counter = 0, object is destroyed

It is important to remember that strong reference cycles (for example, two objects referencing each other with strong references) can lead to memory leaks, so weak or unowned references are used to break such cycles.