Перейти к основному содержимому

5.20. Функции

ДЛЯ НОВИЧКОВНЕ ДЛЯ НОВИЧКОВНЕ ОБЯЗАТЕЛЬНОВ РАЗРАБОТКЕ
Разработчику Архитектору

Функции​

Объявление и вызов функции​

Объявление функции в Zig начинается с ключевого слова fn, за которым следует имя функции, список параметров в круглых скобках и тип возвращаемого значения после двоеточия. Если функция ничего не возвращает, указывается тип void.

Пример простой функции:

fn greet(name: []const u8) void {
    std.debug.print("Привет, {s}!\n", .{name});
}

Эта функция принимает один аргумент — срез байтов ([]const u8), представляющий строку, и ничего не возвращает. Вызов функции происходит стандартным образом:

greet("Мир");

Результат выполнения:

Привет, Мир!

Такой подход делает сигнатуру функции легко читаемой: входные данные слева от двоеточия, выход — справа. Это соответствует философии Zig — делать всё явным и избегать скрытых побочных эффектов.

Параметры функции​

Параметры функции в Zig всегда передаются по значению. Это означает, что внутри функции создаётся копия переданного аргумента. Такой механизм гарантирует, что изменения внутри функции не влияют на исходные данные вызывающего кода.

Однако Zig позволяет передавать ссылки на данные, если требуется изменить оригинал или избежать копирования больших структур. Для этого используется указатель.

Пример функции, принимающей указатель:

fn increment(value: *u32) void {
    value.* += 1;
}

Вызов этой функции:

var counter: u32 = 5;
increment(&counter);
std.debug.print("Счётчик: {}\n", .{counter});

Результат:

Счётчик: 6

Здесь оператор & получает адрес переменной, а * внутри функции разыменовывает указатель. Такой стиль программирования даёт полный контроль над тем, где происходят изменения в памяти, и помогает избежать неожиданных модификаций данных.

Возвращаемые значения​

Функция в Zig возвращает значение с помощью выражения return. Тип возвращаемого значения указывается явно в сигнатуре. Компилятор проверяет соответствие типа возвращаемого значения и объявленного в сигнатуре.

Пример функции с возвратом:

fn add(a: i32, b: i32) i32 {
    return a + b;
}

Вызов:

const result = add(10, 20);
std.debug.print("Сумма: {}\n", .{result});

Результат:

Сумма: 30

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

Функции без имени (анонимные функции)​

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

Если требуется передать поведение как аргумент, Zig использует указатели на функции или шаблоны с comptime.

Пример передачи функции через указатель:

fn applyOperation(x: i32, y: i32, op: fn (i32, i32) i32) i32 {
    return op(x, y);
}

fn multiply(a: i32, b: i32) i32 {
    return a * b;
}

pub fn main() void {
    const result = applyOperation(4, 5, multiply);
    std.debug.print("Результат: {}\n", .{result});
}

Результат:

Результат: 20

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

Функции времени компиляции (comptime)​

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

Это позволяет генерировать код, вычислять константы или проверять условия до запуска программы.

Пример:

fn factorial(n: u32) u32 {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

pub fn main() void {
    const fact5 = comptime factorial(5);
    std.debug.print("5! = {}\n", .{fact5});
}

Значение fact5 вычисляется на этапе компиляции и становится литералом в исполняемом файле. Это не только ускоряет выполнение, но и позволяет использовать такие значения в контекстах, где требуются константы — например, при объявлении размера массива.

const buffer_size = comptime factorial(4); // 24
var buffer: [buffer_size]u8 = undefined;

Такой подход делает Zig мощным инструментом для метапрограммирования без необходимости в макросах или препроцессорах.

Перегрузка функций​

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

Вместо перегрузки Zig предлагает использовать обобщённые функции через comptime-параметры или создавать семейства функций с осмысленными именами.

Пример обобщённой функции:

fn max(comptime T: type, a: T, b: T) T {
    return if (a > b) a else b;
}

pub fn main() void {
    const m1 = max(i32, 10, 20);
    const m2 = max(f32, 3.14, 2.71);
    std.debug.print("Максимумы: {}, {}\n", .{ m1, m2 });
}

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

Обработка ошибок в функциях​

Zig использует систему обработки ошибок, основанную на типах. Функция может возвращать либо значение, либо ошибку. Для этого используется синтаксис !T, где T — тип успешного результата.

Пример функции, которая может завершиться ошибкой:

const std = @import("std");

fn divide(a: f64, b: f64) !f64 {
    if (b == 0.0) return error.DivisionByZero;
    return a / b;
}

Вызов такой функции требует явной обработки ошибки:

pub fn main() void {
    const result = divide(10.0, 0.0) catch |err| {
        std.debug.print("Ошибка: {}\n", .{err});
        return;
    };
    std.debug.print("Результат: {}\n", .{result});
}

Если деление невозможно, функция возвращает ошибку error.DivisionByZero. Оператор catch перехватывает ошибку и позволяет выполнить альтернативные действия. Такой подход делает все возможные пути выполнения явными и исключает игнорирование ошибок.

Альтернативно, можно передать ошибку выше по стеку вызовов, добавив try:

fn safeDivideAndPrint(a: f64, b: f64) !void {
    const result = try divide(a, b);
    std.debug.print("Результат: {}\n", .{result});
}

Здесь try автоматически возвращает ошибку, если она возникла. Это упрощает цепочки вызовов, сохраняя контроль над потоком ошибок.

Вложенные функции​

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

Если требуется локальная логика, её выносят в отдельную функцию с ограниченной областью видимости, используя ключевое слово inline или private.

Пример:

fn process(data: []u8) void {
    var i: usize = 0;
    while (i < data.len) : (i += 1) {
        transformByte(&data[i]);
    }
}

fn transformByte(byte: *u8) void {
    byte.* ^= 0xFF; // инверсия битов
}

Хотя transformByte объявлена отдельно, она служит исключительно для внутренней логики process. Такой стиль поддерживает чистоту и модульность.

Инлайн-функции​

Zig предоставляет возможность пометить функцию как inline. Это указание компилятору встроить тело функции непосредственно в место её вызова, а не генерировать отдельный вызов подпрограммы. Такой подход устраняет накладные расходы на передачу управления и может ускорить выполнение критичных участков кода.

Пример:

inline fn square(x: i32) i32 {
    return x * x;
}

pub fn main() void {
    const val = square(7);
    std.debug.print("Квадрат: {}\n", .{val});
}

Компилятор заменит вызов square(7) на выражение 7 * 7 прямо в теле main. Это особенно полезно для коротких, часто вызываемых функций, где стоимость вызова превышает выигрыш от модульности.

Однако чрезмерное использование inline может увеличить размер исполняемого файла и снизить локальность данных в кэше процессора. Поэтому Zig оставляет решение за разработчиком, не применяя автоматическую инлайн-оптимизацию без явного указания.

Хвостовая рекурсия и оптимизация​

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

Пример рекурсивной функции:

fn factorial(n: u32) u32 {
    if (n == 0) return 1;
    return n * factorial(n - 1);
}

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

Альтернатива с итерацией:

fn factorialIter(n: u32) u32 {
    var result: u32 = 1;
    var i: u32 = 1;
    while (i <= n) : (i += 1) {
        result *= i;
    }
    return result;
}

Такой стиль соответствует философии Zig — предсказуемость поведения важнее автоматических оптимизаций, которые могут скрывать реальные затраты ресурсов.

Функции как часть структур​

Хотя Zig не является объектно-ориентированным языком, он позволяет связывать функции с типами данных через соглашения об именовании. Обычно такие функции принимают первый параметр как указатель на структуру и выполняют над ней операции.

Пример:

const Point = struct {
    x: f32,
    y: f32,

    fn distanceFromOrigin(self: *const Point) f32 {
        return @sqrt(self.x * self.x + self.y * self.y);
    }

    fn translate(self: *Point, dx: f32, dy: f32) void {
        self.x += dx;
        self.y += dy;
    }
};

pub fn main() void {
    var p = Point{ .x = 3.0, .y = 4.0 };
    std.debug.print("Расстояние до начала координат: {:.2}\n", .{p.distanceFromOrigin()});
    p.translate(1.0, 1.0);
    std.debug.print("Новые координаты: ({:.1}, {:.1})\n", .{ p.x, p.y });
}

Здесь методы distanceFromOrigin и translate объявлены внутри структуры Point, но технически остаются обычными функциями. Первый параметр self играет роль получателя, как в других языках. Такой подход сохраняет простоту модели памяти и избегает скрытых виртуальных таблиц или динамической диспетчеризации.

Соглашения о вызовах​

Zig использует стандартные соглашения о вызовах, принятые в целевой архитектуре (например, System V ABI на x86_64). Разработчик может явно указать другое соглашение с помощью атрибута callconv.

Пример вызова функции с C-совместимым соглашением:

extern "c" fn c_style_add(a: c_int, b: c_int) c_int;

export fn add_wrapper(a: i32, b: i32) i32 {
    return c_style_add(@intCast(a), @intCast(b));
}

Атрибут extern "c" указывает, что функция следует соглашению вызова C и может быть вызвана из C-кода или использована в связке с библиотеками на C. Это критически важно при взаимодействии с системными API или существующими библиотеками.

Взаимодействие с C​

Zig изначально спроектирован как язык, совместимый с C. Любая функция на C может быть вызвана из Zig без обёрток, а функции Zig могут экспортироваться в C с помощью ключевого слова export.

Пример экспорта функции в C:

export fn zig_greet(name: [*:0]const u8) void {
    std.debug.print("Привет из Zig: {s}!\n", .{name});
}

Такая функция может быть скомпилирована в разделяемую библиотеку и вызвана из программы на C:

#include <stdio.h>

void zig_greet(const char* name);

int main() {
    zig_greet("C");
    return 0;
}

Это делает Zig мощным инструментом для постепенной замены C-кода, написания системных компонентов или создания высокоэффективных расширений для других языков.

Практические рекомендации по проектированию функций​

При написании функций в Zig рекомендуется придерживаться следующих принципов:

  1. Явность сигнатуры — каждый параметр и возвращаемое значение должны иметь чётко указанный тип. Это упрощает чтение и проверку кода.
  2. Минимизация побочных эффектов — функция должна изменять только те данные, которые переданы через указатели. Избегайте глобального состояния.
  3. Обработка ошибок через типы — используйте систему ошибок Zig (!T) вместо возврата магических значений или игнорирования исключительных ситуаций.
  4. Избегание рекурсии без контроля глубины — предпочитайте итерацию, если нет гарантии ограниченной глубины вызовов.
  5. Использование comptime для константных вычислений — выносите всё, что можно вычислить на этапе компиляции, за пределы времени выполнения.
  6. Согласованность именования — при связывании функций со структурами используйте префикс имени структуры или параметр self для единообразия.

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

Функции с переменным числом аргументов​

Zig не поддерживает функции с переменным числом аргументов в традиционном смысле, как это реализовано в C через stdarg.h. Такой подход считается небезопасным, так как нарушает проверку типов во время компиляции и может привести к неопределённому поведению.

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

Пример с использованием среза:

fn sum(numbers: []const i32) i32 {
    var total: i32 = 0;
    for (numbers) |n| {
        total += n;
    }
    return total;
}

pub fn main() void {
    const values = [_]i32{ 10, 20, 30, 40 };
    const result = sum(&values);
    std.debug.print("Сумма: {}\n", .{result});
}

Здесь массив фиксированного размера преобразуется в срез и передаётся в функцию. Это обеспечивает безопасность границ и полную проверку типов.

Для случаев, когда количество аргументов известно на этапе компиляции, можно использовать кортежи:

fn format(comptime fmt: []const u8, args: anytype) void {
    std.debug.print(fmt, args);
}

pub fn main() void {
    format("Имя: {s}, Возраст: {}\n", .{ "Алексей", 32 });
}

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

Ограничения и проверки на этапе компиляции​

Каждая функция в Zig проходит строгую проверку на этапе компиляции. Компилятор анализирует:

  • соответствие типов параметров и аргументов,
  • корректность возвращаемого значения,
  • использование неинициализированных переменных,
  • потенциальные переполнения при арифметических операциях (в режиме --release-safe),
  • недостижимость кода после return.

Эти проверки исключают целый класс ошибок, характерных для C и C++, где подобные проблемы проявляются только во время выполнения или остаются незамеченными.

Пример ошибки, которую Zig не допустит:

fn bad_example(value: i32) u32 {
    return value; // Ошибка: нельзя неявно преобразовать i32 в u32
}

Компилятор выдаст сообщение о несоответствии типов. Для преобразования требуется явный вызов @intCast или другой встроенной функции, что делает намерение разработчика прозрачным.

Сравнение с функциями в других системных языках​

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

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

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

Такой подход делает Zig особенно подходящим для системного программирования, встраиваемых устройств и ситуаций, где важны детерминированное поведение и контроль над ресурсами.