როგორ გამოიყენება სტეკი და heap მეხსიერებაში?

Stack გამოიყენება ადგილობრივი ცვლადების, ფუნქციის პარამეტრების და დაბრუნების მისამართების შენახვისთვის. მეხსიერება ავტომატურად გამოყოფა და გათავისუფლება ხდება LIFO (Last-In, First-Out) პრინციპით.

Heap გამოიყენება დინამიური მეხსიერების გამოყოფისთვის ობიექტებისთვის, რომლის ზომა უცნობია კომპილაციის დროს ან რომლის სიცოცხლის ხანგრძლივობა აღემატება შექმნის ზონას. მეხსიერების მართვა heap-ზე ხორციელდება ხელით ან მეხსიერების მართვის მექანიზმებით (Swift-ში ARC, სხვა ენებში garbage collector).

ნიშანი	Stack	Heap
განაწილება	ავტომატური	დინამიური (ხელით ან MRC/ARC-ის საშუალებით)
გათავისუფლება	ავტომატური, როდესაც ზონა გამოდის	ხელით (free) ან MRC/ARC-ის საშუალებით
მონაცემების ზომა	კომპილაციის დროს ცნობილი	შეიძლება იყოს უცნობი შესრულებამდე
წვდომა	სწრაფი, სერიული	ნელი, შემთხვევითი
სტრუქტურა	LIFO	ობიექტების გრაფი
მაგალითები	ადგილობრივი ცვლადები, ფუნქციის პარამეტრები	კლასის ობიექტები, ზომის ცვლილებადი სტრუქტურები

// Swift-ში stack და heap გამოყენების მაგალითი

func myFunction() {
    // ადგილობრივი ცვლადი stack-ზე
    var stackVariable: Int = 10

    // კლასის ობიექტი heap-ზე
    let heapObject = MyClass()

    // მნიშვნელობით ტიპი stack-ზე (გარდა სტრუქტურებისა, რომლებიც შეიცავენ რეფერენციულ ტიპებს)
    var stackStruct = MyStruct()

    // სტრუქტურა, რომელიც შეიცავს რეფერენციულ ტიპს, ნაწილობრივ შეიძლება იყოს heap-ზე
    var mixedStruct = MyMixedStruct()
}

class MyClass {
    // ობიექტის თვისებები ინახება heap-ზე
    var property: String = "Hello"
}

struct MyStruct {
    // მნიშვნელობით ტიპის თვისებები ინახება stack-ზე
    var property: Int = 20
}

class MyReferenceType {
    var value: Int = 30
}

struct MyMixedStruct {
    // მნიშვნელობით ტიპი stack-ზე
    var stackProperty: Int = 40
    // რეფერენციული ტიპი heap-ზე (საკუთარი რეფერენცია stack-ზე)
    var heapReference: MyReferenceType = MyReferenceType()
}