Could you give examples of situations where a structure or object is allocated in dynamic memory on the heap?

In iOS, objects and structures are allocated in dynamic memory (heap) in the following cases:

• Class objects (reference types) are always allocated on the heap. For example, when you create an instance of a class using MyClass(), memory for it is allocated on the heap.

• Structures (value types) are usually allocated on the stack, but if a structure contains a large amount of data or is used in a context that requires dynamic storage (for example, stored in a class or closure), they can be placed on the heap.

• Closures that capture variables may allocate memory on the heap to store these variables.

• Using @escaping closures and other situations where the data's lifecycle exceeds the stack context lead to memory allocation on the heap.

Example:

class Person {
    var name: String
    init(name: String) {
        self.name = name
    }
}

let person = Person(name: "Ivan") // object allocated on the heap

struct Point {
    var x: Int
    var y: Int
}

var p = Point(x: 10, y: 20) // structure usually on the stack

// But if the structure is stored in a class:
class Container {
    var point: Point
    init(point: Point) {
        self.point = point
    }
}

let container = Container(point: p) // structure inside a class, actually on the heap

Thus, class objects are always on the heap, structures are usually on the stack but can be on the heap depending on the usage context.