Переменные и константы 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
Значение переменной можно изменить во время выполнения программы:
Пример
pub fn main() void {
var b: i32 = 20; // Определить целочисленную переменную b с начальным значением 20
b = 30; // Изменить значение переменной b
std.debug.print("b: {}\n", .{b});
}
Характеристики переменных
1. Тип должен быть явным:
Zig — строго типизированный язык. Тип переменной должен быть явно указан при определении или выведен из значения инициализации.
Если значение инициализации отсутствует, тип должен быть явно указан.
Пример
var y = 20; // Компилятор выводит тип как comptime_int
2. Изменяемость:
-
Переменные, определённые с помощью
varключевого слова, являются изменяемыми, и их значения можно изменять в последующем коде.
Пример
x = 20; // Изменяем значение x
3. Область видимости:
-
Область видимости переменной является блочной, то есть переменная действительна внутри блока кода, в котором она определена.
Пример
var x: i32 = 10;
std.debug.print("x = {}\n", .{x}); // Вывод: x = 10
}
// Здесь x вне области видимости, и доступ к нему невозможен
4. Неинициализированные переменные:
-
Zig не допускает использования неинициализированных переменных. Если переменная не инициализирована, компилятор сообщит об ошибке.
Пример
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 _value: f64 = 3.14; // Допустимое имя переменной
var 1var: i32 = 10; // Недопустимое имя переменной
Вывод типов
Zig поддерживает вывод типов. Если переменная инициализируется при определении, компилятор может вывести тип переменной из начального значения.
Пример
var y = 3.14; // Компилятор выводит тип y как comptime_float
var z = "Hello"; // Компилятор выводит тип z как *const [5:0]u8
Область действия
Область видимости переменной определяется местом её определения.
В Zig переменные можно определять в глобальной области видимости, локальной области видимости и области видимости блока.
Глобальная область видимости- Глобальные переменные доступны в любом месте программы.
Пример
const g: i32 = 90; // Глобальная константа
pub fn main() void {
std.debug.print("g: {}\n", .{g});
}
Локальная область видимости- Локальные переменные доступны только внутри функции или блока кода, где они определены.
Пример
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 предоставляет функции преобразования типов для преобразования одного типа в другой.
Пример
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 не допускает использования неинициализированных переменных.
Пример
pub fn main() void {
var l: i32 = 0; // Инициализировать переменную l
std.debug.print("l: {}\n", .{l});
}
Примеры использования переменных
Ниже приведена полная программа на Zig, демонстрирующая определение и использование переменных:
Пример
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.
После определения константы её значение нельзя изменить.
Пример
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; // 编译时常量
Характеристики
- Вычисление во время компиляции:Значения констант времени компиляции вычисляются во время компиляции и могут использоваться для логики времени компиляции (например, размеры массивов, вычисления типов и т. д.).
- Безопасность типов:Тип константы времени компиляции должен быть определён во время компиляции.
- Оптимизация производительности:Использование констант времени компиляции позволяет избежать накладных расходов на вычисления во время выполнения.
Пример
pub fn main() void {
comptime const SIZE: usize = 10; // Константа времени компиляции
var arr: [SIZE]i32 = undefined; // Используйте константу времени компиляции для определения размера массива
std.debug.print("Размер массива = {}\n", .{SIZE}); // Вывод: Размер массива = 10
}
Различия между переменными и константами
| Характеристика | Переменная (var) | Константа (const) | Константа времени компиляции (comptime const) |
|---|---|---|---|
| Изменяемость | Изменяемый | Неизменяемый | Неизменяемый |
| Ключевое слово определения | var | const | comptime const |
| Требование к инициализации | Должна быть инициализирована | Должна быть инициализирована | Должна быть инициализирована |
| Вывод типов | Поддерживается | Поддерживается | Поддерживается |
| Область действия | Блочная область видимости | Блочная область видимости | Блочная область видимости |
| Сценарии использования | Значения, требующие изменения | Значения, не требующие изменения | Значения, вычисляемые во время компиляции |
Пример
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
}