Переменные и константы Zig

В языке Zig переменные — это контейнеры для хранения данных.

В Zig определение и использование переменных очень интуитивны и мощны.

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

В Zig константы определяются с помощью ключевого словаconst, а переменные — с помощью ключевого словаvar.


Переменные

В Zig переменные определяются с помощью ключевого словаvar.

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

Объявление переменной

В Zig объявление переменной требует указания типа. Синтаксис объявления переменной выглядит следующим образом:

var variable_name: type = value;

variable_name— имя переменной,type— тип,value— значение переменной.

Например:

var x: i32 = 42; // 定义一个 i32 类型的变量 x,初始值为 42
var y = 10;      // 编译器推断 y 的类型为 comptime_int

Значение переменной можно изменить во время выполнения программы:

Пример

const std = @import("std");

pub fn main() void {
    var b: i32 = 20; // Определить целочисленную переменную b с начальным значением 20
    b = 30; // Изменить значение переменной b
    std.debug.print("b: {}\n", .{b});
}

Характеристики переменных

1. Тип должен быть явным:

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

  • Если значение инициализации отсутствует, тип должен быть явно указан.

Пример

var x: i32 = 10; // Явно указываем тип
var y = 20;      // Компилятор выводит тип как comptime_int

2. Изменяемость:

  • Переменные, определённые с помощьюvarключевого слова, являются изменяемыми, и их значения можно изменять в последующем коде.

Пример

var x: i32 = 10;
x = 20; // Изменяем значение x

3. Область видимости:

  • Область видимости переменной является блочной, то есть переменная действительна внутри блока кода, в котором она определена.

Пример

{
    var x: i32 = 10;
    std.debug.print("x = {}\n", .{x}); // Вывод: x = 10
}
// Здесь x вне области видимости, и доступ к нему невозможен

4. Неинициализированные переменные:

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

Пример

var x: i32; // Ошибка: переменная x не инициализирована
x = 10;    // Сначала должна быть инициализирована

Типы переменных

Zig поддерживает множество типов данных, включая, но не ограничиваясь:

  • Базовые типы: целые числа (i32, i64и т. д.), беззнаковые целые числа (u32, u64и т. д.), числа с плавающей запятой (f32, f64и т. д.), логические значения (bool), символы (char)。
  • Составные типы: массивы ([]T), структуры (struct), перечисления (enum), объединения (union), кортежи ([]const T)。
  • Указатели и ссылки: указатели (*T), ссылки (&T), опциональные типы (?T)。
  • Типы функций:fn(...) -> R。

Правила именования переменных

Именование переменных в Zig следует некоторым основным правилам, включая:

  • Имена переменных должны начинаться с буквы или знака подчёркивания.

  • Имена переменных могут содержать буквы, цифры и знаки подчёркивания.

  • Имена переменных чувствительны к регистру.

  • Имена переменных не могут быть ключевыми словами Zig (такими какvar、const、fnи т.д.).

Пример

var my_var: i32 = 10; // Допустимое имя переменной
var _value: f64 = 3.14; // Допустимое имя переменной
var 1var: i32 = 10; // Недопустимое имя переменной

Вывод типов

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

Пример

var x = 10;      // Компилятор выводит тип x как comptime_int
var y = 3.14;    // Компилятор выводит тип y как comptime_float
var z = "Hello"; // Компилятор выводит тип z как *const [5:0]u8

Область действия

Область видимости переменной определяется местом её определения.

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

Глобальная область видимости- Глобальные переменные доступны в любом месте программы.

Пример

const std = @import("std");

const g: i32 = 90; // Глобальная константа

pub fn main() void {
    std.debug.print("g: {}\n", .{g});
}

Локальная область видимости- Локальные переменные доступны только внутри функции или блока кода, где они определены.

Пример

const std = @import("std");

pub fn main() void {
    var h: i32 = 100; // Локальная переменная
    {
        var i: i32 = 110; // Переменная с областью видимости блока
        std.debug.print("i: {}\n", .{i});
    }
    // std.debug.print("i: {}\n", .{i}); // Эта строка кода вызовет ошибку компиляции, потому что i не находится в области видимости функции main
    std.debug.print("h: {}\n", .{h});
}

Преобразование типов

Zig предоставляет функции преобразования типов для преобразования одного типа в другой.

Пример

const std = @import("std");

pub fn main() void {
    const j: i32 = 120;
    const k: f64 = @intToFloat(f64, j); // Преобразовать целое число j в число с плавающей запятой k
    std.debug.print("j: {}, k: {}\n", .{j, k});
}

Значения по умолчанию

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

Zig не допускает использования неинициализированных переменных.

Пример

const std = @import("std");

pub fn main() void {
    var l: i32 = 0; // Инициализировать переменную l
    std.debug.print("l: {}\n", .{l});
}

Примеры использования переменных

Ниже приведена полная программа на Zig, демонстрирующая определение и использование переменных:

Пример

const std = @import("std");

pub fn main() void {
    // Определить переменную
    var x: i32 = 10;
    var y = 20; // Тип выводится как comptime_int

    // Изменить значение переменной
    x = 30;
    y = 40;

    // Вывести значение переменной
    std.debug.print("x = {}\n", .{x}); // Вывод: x = 30
    std.debug.print("y = {}\n", .{y}); // Вывод: y = 40

    // Область видимости уровня блока
    {
        var z: i32 = 50;
        std.debug.print("z = {}\n", .{z}); // Вывод: z = 50
    }
    // Здесь z вне области видимости, и доступ к ней невозможен
}

Константы

В Zig константы определяются с помощью ключевого словаconst.

После определения константы её значение нельзя изменить.

Пример

const std = @import("std");

pub fn main() void {
    const a: i32 = 10; // Определить целочисленную константу a со значением 10
    std.debug.print("a: {}\n", .{a});
}

Характеристики констант:

  • Неизменяемость: Значение константы нельзя изменить после определения.

  • Определяется во время компиляции: Значение константы должно быть определено во время компиляции и не может быть результатом вычислений во время выполнения.

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

  • Соглашение об именовании: Константы обычно именуются с использованием прописных букв и символов подчёркивания (например,MAX_SIZE), чтобы отличать их от переменных.


Константы времени компиляции

Zig поддерживает константы времени компиляции (comptime-константы). Значения этих констант вычисляются во время компиляции и могут использоваться для логики времени компиляции.

Определение констант времени компиляции

Используйте ключевое слово comptime для определения констант времени компиляции.

Синтаксис:

comptime const constant_name: type = value;

Например:

comptime const MAX_SIZE: usize = 100; // 编译时常量

Характеристики

  • Вычисление во время компиляции:Значения констант времени компиляции вычисляются во время компиляции и могут использоваться для логики времени компиляции (например, размеры массивов, вычисления типов и т. д.).
  • Безопасность типов:Тип константы времени компиляции должен быть определён во время компиляции.
  • Оптимизация производительности:Использование констант времени компиляции позволяет избежать накладных расходов на вычисления во время выполнения.

Пример

const std = @import("std");

pub fn main() void {
    comptime const SIZE: usize = 10; // Константа времени компиляции
    var arr: [SIZE]i32 = undefined;  // Используйте константу времени компиляции для определения размера массива
    std.debug.print("Размер массива = {}\n", .{SIZE}); // Вывод: Размер массива = 10
}

Различия между переменными и константами

ХарактеристикаПеременная (var)Константа (const)Константа времени компиляции (comptime const)
ИзменяемостьИзменяемыйНеизменяемыйНеизменяемый
Ключевое слово определенияvarconstcomptime const
Требование к инициализацииДолжна быть инициализированаДолжна быть инициализированаДолжна быть инициализирована
Вывод типовПоддерживаетсяПоддерживаетсяПоддерживается
Область действияБлочная область видимостиБлочная область видимостиБлочная область видимости
Сценарии использованияЗначения, требующие измененияЗначения, не требующие измененияЗначения, вычисляемые во время компиляции

Пример

const std = @import("std");

pub fn main() void {
    // переменная
    var x: i32 = 10;
    x = 20;
    std.debug.print("x = {}\n", .{x}); // Вывод: x = 20

    // константа
    const PI: f64 = 3.14159;
    std.debug.print("PI = {}\n", .{PI}); // Вывод: PI = 3.14159

    // константа времени компиляции
    comptime const SIZE: usize = 5;
    var arr: [SIZE]i32 = undefined;
    std.debug.print("Размер массива = {}\n", .{SIZE}); // Вывод: Размер массива = 5
}
Другие расширения