Сколько занимает оперативной памяти Reference type?

Объем памяти Reference Type в iOS

Короткий ответ: Сам по себе указатель (reference) на экземпляр класса (reference type) в 64-битной системе занимает 8 байт (64 бита). Однако это лишь стоимость ссылки. Реальная память, занимаемая самим экземпляром класса, выделяется в куче (heap) и может быть значительно больше — она зависит от суммы размеров всех хранимых свойств, накладных расходов системы и механизмов ARC.

Детальное объяснение

Важно различать два понятия:

1. Ссылка (Reference/Указатель): Переменная или константа, которая хранит адрес памяти, где находится реальный объект.
2. Сам объект (Instance): Реальные данные, хранящиеся по этому адресу в куче.

1. Размер ссылки (Stack Memory)

Когда вы объявляете переменную класса, под нее выделяется память в стеке (stack). В этой ячейке хранится не сам объект, а 64-битный указатель на адрес в куче.

class MyClass {
    var value: Int = 10
}

let objectRef: MyClass? = MyClass() // В стеке выделяется 8 байт под 'objectRef'

Размер ссылки всегда фиксирован:

• 64-битная архитектура (все современные устройства Apple): 8 байт.
• 32-битная архитектура: 4 байта (уже не актуально для iOS).

Если ссылка является опциональной (Optional), под капотом это Optional<MyClass>, который является еnum-ом. Для reference type он занимает те же 8 байт для хранения самого указателя плюс 1 байт для дискриминанта (case), но из-за выравнивания памяти общий размер часто также составляет 8 байт.

2. Размер объекта в куче (Heap Memory)

Реальное потребление памяти начинается при создании экземпляра (MyClass()). Система выделяет блок памяти в куче. Его размер складывается из:

• Накладные расходы (Overhead): Каждый объект в куче имеет служебный заголовок. В среде Apple (Objective-C/Swift с участием Objective-C runtime) это минимум 16 байт (на 64-битной системе). Этот заголовок содержит указатель на метаданные класса (isa pointer) и данные для управления жизненным циклом (счетчики ссылок ARC).
• Память под хранимые свойства: Сумма размеров всех свойств экземпляра с учетом выравнивания памяти (alignment).

    *   `Int`, `Double`: 8 байт
    *   `Float`, `Int32`: 4 байта
    *   `Bool`: 1 байт (но может выравниваться)
    *   Другая ссылка (`String`, `Array`, другой класс): +8 байт для указателя.

• Выравнивание (Alignment): Система может добавлять "пустые" байты (padding) между свойствами или в конце объекта, чтобы адреса данных соответствовали машинным словам (часто по 8 байт), что ускоряет доступ.

Пример расчета:

class Profile {
    var id: Int64 = 0      // 8 байт
    var isActive: Bool = true // ~1 байт (фактически может занять больше из-за выравнивания)
    var name: String? = nil // 8 байт (ссылка на String)
    var score: Double = 0.0 // 8 байт
}

1. Overhead: ~16 байт.
2. Свойства: id (8) + isActive (~1, но с паддингом до 8) + name (8) + score (8) = ~32 байта.
3. Итого (приблизительно): 16 + 32 = 48 байт на один экземпляр Profile в куче.

Узнать точный размер можно косвенными методами:

import Foundation

class SimpleClass {
    var number: Int = 5
}

let instance = SimpleClass()
let size = malloc_size(Unmanaged.passUnretained(instance).toOpaque())
print("Реальный размер в куче (с округлением): \(size) байт")
// Может вывести, например, 32 байта (16 overhead + 8 для number + выравнивание).

Критические аспекты для iOS-разработчика

• ARC и счетчики ссылок: В заголовке объекта хранятся счетчики сильных (strong) ссылок. Каждая новая сильная ссылка увеличивает счетчик. Это не увеличивает размер объекта, но управление ARC создает дополнительную вычислительную нагрузку.
• Куча vs Стек: Частое создание/удаление мелких объектов в куче может привести к фрагментации памяти и затратам на выделение/освобождение, что менее эффективно, чем работа со value type (структурами) в стеке. Это ключевой момент при оптимизации производительности.
• Структуры (Value Type) могут быть выгоднее: Для небольших, кратковременных данных использование struct предпочтительнее, так как оно:

    *   Исключает накладные расходы кучи (~16 байт).
    *   Исключает затраты на подсчет ссылок ARC.
    *   Память выделяется в стеке (быстрее).
    *   Копируются, что обеспечивает thread safety по умолчанию.

Вывод: Говорить о памяти reference type, учитывая только 8 байт ссылки, — сильное упрощение. Основной расход происходит в куче и включает неминуемые накладные расходы (16+ байт). Поэтому для инкапсуляции простых данных (Point, Rect, примитивные модели) в Swift повсеместно используются value type (struct), что является одной из ключевых оптимизаций языка по сравнению с чисто объектными языками. При проектировании классов всегда следует помнить о реальном "весе" их экземпляров в куче.