Как хранятся объекты в памяти у массива?

Хранение объектов массива в памяти iOS

В iOS/macOS массивы (например, NSArray в Objective-C или Array в Swift) хранят объекты не так, как примитивные типы в C-подобных языках. Основное различие заключается в том, что массивы хранят не сами объекты, а указатели (ссылки) на эти объекты.

Структура хранения в памяти

NSArray (Objective-C)

// NSArray хранит указатели на объекты в куче (heap)
NSArray *array = @[[[MyClass alloc] init], @"String", @42];

В памяти это выглядит примерно так:

Массив (стек/куча)
├── Ссылка 0x1000 → Объект MyClass (куча)
├── Ссылка 0x2000 → Объект NSString (куча)
└── Ссылка 0x3000 → Объект NSNumber (куча)

Array (Swift)

// Swift Array для ссылочных типов (классы) хранит указатели
class MyClass {}
let array: [AnyObject] = [MyClass(), "String" as NSString, 42 as NSNumber]

// Для значений (value types) хранятся сами значения
let intArray = [1, 2, 3] // Значения хранятся contiguously в памяти

Ключевые особенности хранения

1. Ссылочная семантика для объектов

• Массив содержит strong references на объекты (если не указано иное)
• Каждый элемент массива - это 8-байтовый указатель (на 64-битных системах)
• Объекты располагаются в куче (heap), а массив хранит указатели на них

// Демонстрация ссылочной семантики
class Person {
    var name: String
    init(name: String) { self.name = name }
}

let person = Person(name: "Иван")
let array = [person]

person.name = "Петр"
print(array[0].name) // "Петр" - изменения видны через массив

2. Непрерывное выделение памяти для указателей

• Указатели на объекты хранятся в непрерывном блоке памяти
• Это обеспечивает быстрый доступ по индексу O(1)
• При добавлении элементов массив может быть перераспределен

// Примерная структура в памяти (C-подобная)
struct NSArrayImpl {
    void **buffer;       // Указатель на массив указателей
    NSUInteger count;    // Количество элементов
    NSUInteger capacity; // Выделенная емкость
};

3. Copy-on-write оптимизация в Swift

• Для value types Swift использует оптимизацию copy-on-write
• Массивы копируются только при модификации

var array1 = [1, 2, 3]
var array2 = array1 // Нет копирования данных

array2.append(4) // Только здесь происходит копирование

Управление памятью

Strong Reference Cycles

class Node {
    var children: [Node] = []
}

var node1: Node? = Node()
var node2: Node? = Node()

node1?.children.append(node2!)
node2?.children.append(node1!) // Цикл сильных ссылок!

Weak/Unowned References

class Node {
    weak var parent: Node? // Слабая ссылка
    var children: [Node] = []
}

Особенности производительности

1. Доступ по индексу: O(1) - прямой доступ через указатель
2. Вставка в конец:
   • O(1) в среднем случае
   • O(n) при перераспределении памяти
3. Вставка в середину: O(n) - требует сдвига указателей
4. Поиск элемента: O(n) - линейный поиск

Память для разных типов

// Для классов (ссылочные типы)
let classArray = [UIView(), UILabel()] // Хранятся указатели (8 байт каждый)

// Для структур (значения)
let structArray = [CGPoint(x: 0, y: 0), CGPoint(x: 1, y: 1)] 
// Хранятся сами структуры (16 байт каждая)

// Для примитивов
let intArray = [1, 2, 3] // Значения хранятся напрямую

Оптимизации компилятора

1. Array Contiguity: Swift гарантирует непрерывное хранение для одного типа
2. Buffer Reusing: При удалении элементов память не всегда освобождается сразу
3. Bridge to Objective-C: Swift массивы автоматически бриджатся в NSArray при необходимости

Вывод

Хранение объектов в массивах iOS является компромиссом между производительностью и гибкостью. Система использует:

• Ссылки на объекты для поддержки полиморфизма и динамической типизации
• Непрерывные блоки памяти для быстрого доступа
• Умное управление памятью через ARC и copy-on-write

Понимание этих механизмов критично для написания эффективных iOS-приложений, особенно при работе с большими объемами данных или в требовательных к производительности сценариях.