Боитесь, что указатели завершат вашу карьеру программиста фейерверком ошибок времени выполнения? Расслабьтесь. К тому моменту, как вы закончите эту главу, вы увидите указатели такими, какие они есть на самом деле: просто ещё один инструмент для управления памятью. Вы узнаете, почему подход Zig к указателям, выделению памяти и владению — это не злой лабиринт неопределённого поведения, а ясная и понятная сделка: вам нужна память — вы её выделяете, вы ею владеете и вы её освобождаете. Никаких догадок не требуется.

В этой главе вы узнаете, как обращаться с указателями, не теряя рассудка, безопасно управлять стеком и кучей, а также погрузитесь в продвинутые приёмы, такие как типы нулевого размера и приведение типов (кастинг). Каждая подтема покажет вам, как дизайн Zig помогает сохранять контроль над вашей памятью, при этом наслаждаясь скоростью и эффективностью.

В этой главе мы рассмотрим следующие темы:

  • Стек и куча: двуглавый зверь памяти.
  • Указатели: хорошие, плохие и злые (но в основном хорошие).
  • Выделение памяти: искусство просить больше памяти (и получать её).
  • Соображения о времени жизни.
  • Типы нулевого размера: фантомная угроза управления памятью (но у них есть своё применение).
  • Приведение типов (кастинг): когда вашим данным нужна маскировка.

К концу этой главы вы не только научитесь правильно работать с указателями и выделением памяти, но и убирать за собой мусор так, чтобы ваш компьютер вас не возненавидел — или не упал. Вы уйдёте с уверенностью в решении реальных проблем, таких как утечки памяти, ошибки использования после освобождения и огромные выделения в куче.

В повседневном программировании и системных задачах правильное управление памятью не подлежит обсуждению. Независимо от того, создаёте ли вы низкоуровневое приложение, которое никогда не должно падать, или просто хотите выйти за рамки языков «просто работает», Zig даёт вам силу и ясность для явного управления памятью. Изучите эти концепции здесь, и вы будете готовы ко всему: от отладки странных проблем с указателями в ваших собственных проектах до создания надёжного программного обеспечения, выдерживающего производственную нагрузку.

Технические требования

Весь код, показанный в этой главе, можно найти в каталоге Chapter09 нашего репозитория Git.

Стек и куча: двуглавый зверь памяти

Если вы когда-либо пытались выяснить, где живут ваши данные во время выполнения программы, вы, вероятно, слышали о стеке и куче. Вот краткая версия: это не лекция по информатике, а лишь основы, чтобы вы понимали, что происходит. Готовы к скоростному прохождению?

Память и процессы (вкратце)

Во-первых, память на самом деле принадлежит компьютеру, а ядро — это ворчливый арендодатель, который выделяет её процессам. Процесс — это, по сути, дескриптор, который ОС использует для управления запущенными программами, отслеживания открытых файлов и отображения того, какие области памяти вам разрешено использовать. Вы получаете кусок доступной пользователю памяти, который включает в себя стек, кучу и несколько других областей, таких как глобальные данные, константы только для чтения и неинициализированные (BSS) сегменты.

Представьте себе два разных складских помещения в одном здании: одно маленькое, безопасное и лёгкое для входа и выхода, другое — огромное и более гибкое, но требующее больше усилий для управления. В этом суть того, как стек и куча работают внутри адресного пространства вашей программы.

Стек

Стек — это высокоорганизованная область памяти для локальных переменных функции. Представьте это как временное рабочее пространство: когда вызывается функция, она получает новую чистую область для работы.

Когда функция завершается, всё это рабочее пространство мгновенно и автоматически очищается. Этот строгий упорядоченный процесс делает выделение стека таким быстрым, поскольку не требует ручной очистки или сложного поиска в памяти.

Однако стек ограничен по размеру. Если вы попытаетесь запихнуть туда огромный массив или вложить слишком много вызовов функций, вы рискуете попасть на сторожевую страницу (guard page) и вызвать сбой. Linux часто устанавливает размер основного потока стека по умолчанию около 8 МБ, который может быстро исчезнуть, если вы будете неосторожны.

Вот почему данные в стеке обычно должны быть известного скромного размера на этапе компиляции.

Это можно резюмировать следующим образом:

  • Он ограничен. Вы не можете просто вечно складывать туда вещи. Взорвите его огромным локальным массивом или сумасшедшей рекурсией — и вы получите сбой (знаменитая ошибка переполнения стека).
  • Вы должны знать размеры своих переменных на этапе компиляции. Никаких массивов «на всякий случай» по 50 МБ (если только вам не нравятся сегфолты).

Куча

Кучу можно представить как большой складской комплекс, который вы арендуете по мере необходимости. Вы можете запросить столько площади пола, сколько вам нужно, при условии, что у ядра есть ресурсы. В Zig аллокатор выступает посредником в этих запросах, забирая память у ядра большими кусками, а затем распределяя её для вашего кода.

Эта гибкость фантастична для непредсказуемых или больших выделений данных, но как только вы закончите с этим складским пространством, вы должны освободить его самостоятельно. В противном случае вы будете продолжать платить аренду за пустые полки и в конечном итоге у вас закончится место. Выделение и освобождение в куче также сложнее выделения стека, поэтому это может быть медленнее и подвержено фрагментации, когда приходит и уходит множество запросов разного размера.

Нужен огромный массив, но вы не уверены в его размере или ожидаете динамического роста? Вы просите аллокатор (в Zig это может быть что-то вроде std.heap.page_allocator или кастомный аллокатор) выделить больше места, и аллокатор вежливо запрашивает кусок у ядра. Если операционная система говорит: «Конечно», вы получаете свою память. Если нет — не повезло. Кроме того, вы должны освободить её, когда закончите (не будьте тем человеком, который забывает это сделать и устраивает утечки памяти повсюду).

FYI:

В 32-битной системе ваша программа живёт в небольшом 4-гигабайтном виртуальном адресном пространстве. Куча растёт вверх (upward), а стек — вниз (downward), поэтому места не так много до того, как они столкнутся. Это столкновение может привести к сбою вашей программы (или ядро может отказать в дальнейших выделениях).

В отличие от этого, 64-битные системы имеют гораздо больше виртуального пространства, поэтому столкновения кучи и стека встречаются реже, и ваша программа может дышать свободнее. «Насколько больше?» — спросите вы. Как насчёт 16 экзабайт? Лично я думаю, этого достаточно.

Другие разделы (мы клянёмся, они существуют)

Помимо стека и кучи, у вашего процесса также есть области для глобальных данных, кода, BSS (неинициализированные данные) и других. Эти разделы в основном обрабатываются операционной системой или загрузчиком, и вы редко возитесь с ними напрямую. Например, если вы объявляете глобальные переменные в Zig, некоторые из них попадают в сегмент данных, а обнулённые могут оказаться в BSS. Полезно знать об их существовании, но это не то, с чем вы обычно возитесь на ежедневной основе, если только не отлаживаете сложную ошибку или не работаете над кастомным загрузчиком.

Теперь, когда мы подготовили почву, поговорив о стеке и куче, пришло время посмотреть, как мы на самом деле получаем ссылки на данные в этих областях: без копирования всего подряд или взрыва нашей программы. Встречайте указатели — врата к мощным (и потенциально опасным) манипуляциям с памятью.

Указатели: хорошие, плохие и злые (но в основном хорошие)

Ах, указатели. Упомяните их в комнате, полной программистов, и вы увидите целый спектр реакций: от ветеранов с закатанными глазами до новобранцев, беззвучно шепчущих: «О нет, только не снова». Но в Zig указатели не стремятся вас достать (в большинстве случаев). Это просто ещё один хорошо определённый инструмент, который поможет вам управлять памятью. Думайте о них как о ссылках с чуть большей честностью и меньшим количеством страховочных сеток. Никаких иллюзий: только вы, ваши данные и ваше благоразумие.

Давайте посмотрим правде в глаза: в системном программировании далеко не уйти без указателей. Они как секретный ингредиент, который делает всё возможным, и одновременно главный подозреваемый, когда что-то идёт ужасно не так. В Zig указатели бывают нескольких форм и размеров, позволяя вам ссылаться на память структурированным способом, не таская за собой всю полезную нагрузку данных.

Позвольте мне представить вам причину существования указателей, их различные формы и то, как они помогают вам приручать память. По пути мы увидим фрагменты кода, которые иллюстрируют мощь указателей и предупреждают нас быть начеку. Никому ведь не хочется из-за случайного нулевого указателя устроить крах в 3 часа ночи, верно?

Зачем вообще возиться с указателями?

Помните, когда мы говорили о стеке и куче? Стек быстрый и опрятный, но имеет ограниченное пространство, и вам лучше заранее знать, сколько вам нужно. Куча позволяет хранить большие или непредсказуемые по размеру данные, но требует от вас управлять памятью (выделять, а затем освобождать), как будто вы арендуете складскую ячейку. Указатели — это ключ к этому складу. Вместо того чтобы таскать огромные массивы в стеке, вы можете просто передать указатель на данные — это как передать кому-то ключ от вашей ячейки хранения вместо того, чтобы катить всё содержимое по коридору.

Грубо говоря, указатели решают две большие проблемы:

  • Вы не всегда можете знать размер объекта на этапе компиляции.
  • Даже если вы знаете, вы можете не хотеть копировать эти данные.

Конечно, у указателей есть свои болевые точки: висячие ссылки (dangling references), утечки памяти (memory leaks), проблемы с выравниванием (alignment issues) и так далее. Но при ответственном использовании они — ваш лучший выбор для эффективной работы с памятью, особенно в таком языке, как Zig, который стремится дать вам производительность C с меньшим количеством потенциальных проблем.

Говоря об этом, модель указателей в Zig одновременно проще и более явная, чем та, к которой вы могли привыкнуть в таких языках, как C. У вас есть указатели на один элемент и указатели на несколько элементов (many-item pointers), каждый со своими возможностями и ограничениями. Ваша миссия, если вы решитесь её принять — научиться использовать эти сырые ссылки на память, не отстрелив себе ногу.

Получение указателя: & (адрес от)

Начнём с классического оператора «адрес от» — &:

const std = @import("std");
const expect = std.testing.expect;

test "managing player health using pointers" {
    const npc_health: i32 = 100;
    const npc_health_ptr = &npc_health;

    try expect(npc_health_ptr.* == 100);
    try expect(@TypeOf(npc_health_ptr) == *const i32);

    var player_health: i32 = 150;
    const player_health_ptr = &player_health;
    try expect(@TypeOf(player_health_ptr) == *i32);

    player_health_ptr.* -= 20;
    try expect(player_health_ptr.* == 130);
    try expect(player_health == 130)
}

Запуск примеров:

В наших исследованиях мы пройдём через несколько тестов, демонстрирующих основы работы с указателями. Вы можете запустить их с помощью команды zig test <filename>.zig.

Не торопитесь, исследуйте и попытайтесь понять, что происходит в этих тестах. Как только почувствуете себя готовым — переходите к следующему объяснению.

В этом тесте здоровье NPC представлено константой (npc_health) с начальным значением 100. Мы берём его адрес (&npc_health), получая указатель типа *const i32 (указатель на константное целое число). Поскольку указатель указывает на неизменяемое значение, его можно только читать, но не изменять.

Далее здоровье игрока представлено изменяемой переменной (player_health) с начальным значением 150. Взятие адреса этой переменной даёт *i32 (указатель на изменяемое целое число). Используя этот указатель, мы симулируем получение игроком урона путём прямого изменения значения здоровья (player_health_ptr.* -= 20).

Этот небольшой фрагмент на удивление подчёркивает функции безопасности памяти Zig: явная изменяемость (mutability), семантика указателей и безопасность на этапе компиляции.

Примечание о преимуществах указателей:

Вы можете подумать, что использование указателя для одного i32 не даёт большого прироста производительности — и будете правы. Настоящая мощь становится очевидной при работе с большими структурами. Представьте структуру с десятками полей, копировать её каждый раз при передаче в функцию было бы медленно и затратно по памяти. Передавая вместо этого указатель, вы копируете только адрес памяти (несколько байт), что даёт эффективный доступ к исходным данным без накладных расходов.

Явная изменяемость

Вы можете изменять данные только в том случае, если тип указателя и изменяемость исходной переменной это позволяют. Это предотвращает случайные побочные эффекты в коде.

Когда мы берём адрес неизменяемой переменной (const), результирующий тип указателя — *const T (указатель на константное значение). Это гарантирует, что вы не сможете изменить значение через этот указатель. С другой стороны, когда мы берём адрес изменяемой переменной (var), результирующий тип указателя — *T (указатель на изменяемое значение). Это позволяет вам изменять значение, на которое ссылается указатель.

Семантика указателей

Zig обеспечивает строгую типизацию для указателей. Программа проверяет во время выполнения (и неявно на этапе компиляции), что указатель на константную переменную имеет тип *const T, в то время как указатель на изменяемую переменную имеет тип *T. Это принудительное применение типов гарантирует, что вы не сможете случайно изменить неизменяемые переменные или неправильно использовать изменяемые.

Делая изменяемость указателей явной в их типах, Zig предоставляет чёткую и предсказуемую модель для работы с памятью.

Безопасность на этапе компиляции

После взятия адреса изменяемой переменной (var) программа изменяет её значение через указатель (y_ptr.*). Эта операция выполняется успешно, поскольку тип указателя позволяет выполнять изменения. Обновлённое значение проверяется путём повторного разыменования указателя.

Система типов Zig отлавливает многие потенциальные ошибки, связанные с изменяемостью и неправильным использованием указателей, на этапе компиляции.

Что, если взять адрес только одного элемента в массиве?

Доступ к элементам массива через указатель

В Zig массивы не могут содержать константные значения, попытка объявить массив, такой как [_]const u8, приведёт к ошибке компиляции. Из-за этого правила, когда вы берёте адрес элемента внутри массива, вы получаете указатель на тип элемента, а не указатель на константное значение внутри массива. Для изменяемого массива (var) вы получаете указатель *T. Для неизменяемого массива (const) вы получаете указатель *const T. Если вы хотите изменять данные через указатель, исходный массив должен быть изменяемым с самого начала.

Таким образом, с массивами вы получаете указатель на один элемент (*T), поэтому арифметика указателей не разрешена.

Для изменяемых данных вы получаете *T. Для неизменяемых данных вы получаете *const T. Zig не позволяет вам незаметно отбрасывать const. Если вы хотите выполнять мутации через указатель, он должен быть изменяемым с самого начала.

Но вы всё равно можете разыменовать его для чтения или записи этого элемента:

test "upgrading player inventory slots using pointers" {
    var inventory_slots = [_]u8 { 1, 2, 3, 4, 5 };
    const slot_ptr = &inventory_slots[2];

    try expect(@TypeOf(slot_ptr) == *u8); // Указатель на изменяемый u8
    try expect(slot_ptr.* == 3);

    slot_ptr.* += 1;
    try expect(inventory_slots[2] == 4); // 3-й слот теперь на уровне 4
}

Давайте разберём этот пример:

  • Массив inventory_slots представляет уровни различных ячеек инвентаря игрока, инициализированный значениями {1, 2, 3, 4, 5}.
  • Указатель slot_ptr создаётся с помощью оператора адреса (&) и указывает на третью ячейку (inventory_slots[2]), которая изначально имеет значение 3.
  • Указатель slot_ptr используется для увеличения значения третьей ячейки (slot_ptr.* += 1).
  • Поскольку inventory_slots является изменяемым, эта мутация напрямую влияет на массив.

Тест гарантирует следующее:

  • Тип указателя — *u8, что подтверждает его изменяемость.
  • Значение в третьей ячейке правильно обновляется, чтобы отразить его (4).

Синтаксис ptr.* явно разыменовывает указатель, делая ясным, что вы обращаетесь к значению по адресу памяти указателя. Другими словами, ptr.* — это просто причудливый способ сказать: «вещь по адресу ptr