Где хранятся Value type?

Где хранятся Value type?

Основной ответ: Value type обычно хранятся на СТЕКЕ, но есть важные исключения, которые нужно понимать при разработке на Swift.

Базовое правило

Value types (struct, enum, Int, String, Array и т.д.) хранятся на стеке по умолчанию:

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

func example() {
    let p = Point(x: 10, y: 20)  // Point — полностью на стеке
    let number = 42              // Int — на стеке
    let name = "John"            // String value — на стеке (но может содержать heap-ссылку)
}
// При выходе из функции все эти переменные автоматически удаляются

Исключения: Value type в heap

1. Value type внутри Reference type

class User {
    var age: Int = 0          // хранится в heap (как часть объекта класса)
    var point: Point = Point() // Point также в heap
}

let user = User()
// Объект User в heap, а его свойства age и point тоже в heap
// (потому что они часть объекта в heap)

2. String — специальный case

String в Swift — это value type, но внутри использует индиректное хранение для оптимизации:

let str = "Hello, World!"  // переменная str на стеке
                            // но сама строка может кешироваться
                            // при копировании используется Copy-on-Write (CoW)

StringCoW означает: строка копируется на стеке (как reference), но данные в heap копируются только когда происходит модификация.

3. Array, Dictionary — также Copy-on-Write

var arr1 = [1, 2, 3]  // переменная arr1 на стеке
var arr2 = arr1       // arr2 указывает на те же данные в heap (CoW)
arr2.append(4)        // только сейчас копируются данные

// arr1 остаётся [1, 2, 3], arr2 становится [1, 2, 3, 4]

Переменные arr1 и arr2 на стеке, но сами массивы на heap, и Swift оптимизирует копирование.

Практический пример: где что хранится

struct Address: Codable {
    let street: String      // value type, но String использует heap
    let city: String
}

struct Person {
    let name: String        // на стеке (переменная) + heap (данные)
    let age: Int           // на стеке полностью
    let address: Address   // на стеке (переменная) + heap (String данные)
}

func test() {
    let person = Person(
        name: "Alice",
        age: 30,
        address: Address(street: "Main St", city: "NYC")
    )
    // person переменная — на стеке
    // name.value, address.street.value — в heap
    // age целиком — на стеке
}

Стек vs Heap для Value types

Важное: Stack allocation vs Copy-on-Write

Value types с Enum и Struct:

• Enum — если associated value Small, может быть на стеке; если большой — heap
• String/Array — используют CoW для оптимизации

enum Result<T> {
    case success(T)
    case failure(String)  // String может быть на heap
}

Производительность

Преимущества стека:

• Линейное выделение памяти (очень быстро)
• Автоматическое освобождение при выходе из scope
• Лучше для кеша CPU

Когда Value type идёт в heap:

• Это может замедлить программу (требуется ARC для управления)
• Нужна synchronization при многопоточности

Итоговая схема

// На СТЕКЕ:
let x = 42
let str = "Hello"
var p = Point(x: 1, y: 2)

// На HEAP или частично:
let arr = [1, 2, 3]              // массив в heap
let user = User()                // объект в heap, его свойства тоже
let dict = ["key": "value"]     // dictionary в heap

Вывод: Value type по умолчанию на стеке, но благодаря Copy-on-Write и использованию в других контекстах (внутри reference types, массивов) часто имеют данные в heap. Swift компилятор оптимизирует это автоматически для производительности.