How are the stack and heap used in memory?

The stack is used for storing local variables, function parameters, and return addresses. Memory is allocated and freed automatically, following the LIFO (Last-In, First-Out) principle.

The heap is used for dynamically allocating memory for objects whose size is unknown at compile time or whose lifetime exceeds the scope in which they are created. Memory management on the heap is done manually or with memory management mechanisms (ARC in Swift, garbage collector in other languages).

Attribute	Stack	Heap
Allocation	Automatic	Dynamic (manual or with MRC/ARC)
Deallocation	Automatic when leaving scope	Manually (free) or with MRC/ARC
Data size	Known at compile time	May be unknown until runtime
Access	Fast, sequential	Slower, arbitrary
Structure	LIFO	Object graph
Examples	Local variables, function parameters	Class objects, variable-sized structures

// Example of using stack and heap in Swift

func myFunction() {
    // Local variable on the stack
    var stackVariable: Int = 10

    // Class object on the heap
    let heapObject = MyClass()

    // Value type on the stack (except for structures containing reference types)
    var stackStruct = MyStruct()

    // Structure containing a reference type, part of which may be on the heap
    var mixedStruct = MyMixedStruct()
}

class MyClass {
    // Properties of the object are stored on the heap
    var property: String = "Hello"
}

struct MyStruct {
    // Properties of the value type are stored on the stack
    var property: Int = 20
}

class MyReferenceType {
    var value: Int = 30
}

struct MyMixedStruct {
    // Value type on the stack
    var stackProperty: Int = 40
    // Reference type on the heap (the reference itself is on the stack)
    var heapReference: MyReferenceType = MyReferenceType()
}