Сочетания клавиш

Нажмите ← или → для навигации между главами

Нажмите S или / для поиска по книге

Нажмите ?, чтобы показать эту справку

Нажмите Esc, чтобы скрыть эту справку

Типы данных

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

Следует помнить, что Rust — это язык со статической типизацией, что означает, что он должен знать типы всех переменных во время компиляции. Компилятор обычно может вывести, какой тип мы хотим использовать, на основе значения и того, как мы его используем. В случаях, когда возможно множество типов, например, когда мы преобразовали String в числовой тип с помощью parse в разделе «Сравнение догадки с секретным числом» во второй главе, мы должны добавить аннотацию типа, вот так:

#![allow(unused)]
fn main() {
let guess: u32 = "42".parse().expect("Not a number!");
}

Если мы не добавим аннотацию типа : u32, показанную в предыдущем коде, Rust отобразит следующую ошибку, которая означает, что компилятору нужно больше информации от нас, чтобы знать, какой тип мы хотим использовать:

$ cargo build
   Compiling no_type_annotations v0.1.0 (file:///projects/no_type_annotations)
error[E0284]: type annotations needed
 --> src/main.rs:2:9
  |
2 |     let guess = "42".parse().expect("Not a number!");
  |         ^^^^^        ----- type must be known at this point
  |
  = note: cannot satisfy `<_ as FromStr>::Err == _`
help: consider giving `guess` an explicit type
  |
2 |     let guess: /* Type */ = "42".parse().expect("Not a number!");
  |              ++++++++++++

For more information about this error, try `rustc --explain E0284`.
error: could not compile `no_type_annotations` (bin "no_type_annotations") due to 1 previous error

Для других типов данных вы увидите другие аннотации типов.

Скалярные типы

Скалярный тип представляет одно значение. В Rust есть четыре основных скалярных типа: целые числа, числа с плавающей точкой, логические значения и символы. Возможно, вы узнаете их из других языков программирования. Давайте рассмотрим, как они работают в Rust.

Целочисленные типы

Целое число — это число без дробной части. Во второй главе мы использовали один целочисленный тип — u32. Это объявление типа указывает, что значение, с которым он связан, должно быть беззнаковым целым числом (знаковые целочисленные типы начинаются с i, а не с u), занимающим 32 бита пространства. В таблице 3-1 показаны встроенные целочисленные типы в Rust. Мы можем использовать любой из этих вариантов для объявления типа целочисленного значения.

Таблица 3-1: Целочисленные типы в Rust

ДлинаЗнаковыйБеззнаковый
8-битi8u8
16-битi16u16
32-битi32u32
64-битi64u64
128-битi128u128
Зависит от архитектурыisizeusize

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

Каждый знаковый вариант может хранить числа от −(2n − 1) до 2n − 1 − 1 включительно, где n — количество битов, которое использует этот вариант. Так, i8 может хранить числа от −(27) до 27 − 1, что равно −128 до 127. Беззнаковые варианты могут хранить числа от 0 до 2n − 1, так что u8 может хранить числа от 0 до 28 − 1, что равно 0 до 255.

Кроме того, типы isize и usize зависят от архитектуры компьютера, на котором выполняется программа: 64 бита, если вы на 64-битной архитектуре, и 32 бита, если вы на 32-битной архитектуре.

Целочисленные литералы можно записывать в любой из форм, показанных в таблице 3-2. Обратите внимание, что числовые литералы, которые могут быть нескольких числовых типов, допускают суффикс типа, например 57u8, для обозначения типа. Числовые литералы также могут использовать _ в качестве визуального разделителя, чтобы число было легче читать, например 1_000, что будет иметь то же значение, как если бы вы указали 1000.

Таблица 3-2: Целочисленные литералы в Rust

Числовые литералыПример
Десятичный98_222
Шестнадцатеричный0xff
Восьмеричный0o77
Двоичный0b1111_0000
Байт (только u8)b'A'

Так как же узнать, какой тип целого числа использовать? Если вы не уверены, значения по умолчанию в Rust, как правило, являются хорошей отправной точкой: целочисленные типы по умолчанию — i32. Основная ситуация, в которой вы бы использовали isize или usize, — это индексация некоторой коллекции.

Целочисленное переполнение

Допустим, у вас есть переменная типа u8, которая может хранить значения от 0 до 255. Если вы попытаетесь изменить переменную на значение вне этого диапазона, например 256, произойдёт целочисленное переполнение, которое может привести к одному из двух вариантов поведения. При компиляции в режиме отладки Rust включает проверки целочисленного переполнения, которые вызывают панику программы во время выполнения, если такое поведение происходит. Rust использует термин паника, когда программа завершается с ошибкой; мы обсудим паники более подробно в разделе «Невосстановимые ошибки с panic!» в девятой главе.

При компиляции в режиме релиза с флагом --release Rust не включает проверки целочисленного переполнения, которые вызывают паники. Вместо этого, если происходит переполнение, Rust выполняет переполнение дополнительного кода. Короче говоря, значения, большие максимального значения, которое может хранить тип, «заворачиваются» к минимуму значений, которые может хранить тип. В случае u8 значение 256 становится 0, значение 257 становится 1 и так далее. Программа не запаникует, но переменная будет иметь значение, которое, вероятно, не то, что вы ожидали получить. Полагаться на поведение заворачивания при целочисленном переполнении считается ошибкой.

Чтобы явно обработать возможность переполнения, вы можете использовать эти семейства методов, предоставляемых стандартной библиотекой для примитивных числовых типов:

  • Заворачивать во всех режимах компиляции с помощью методов wrapping_*, таких как wrapping_add.
  • Возвращать значение None, если есть переполнение, с помощью методов checked_*.
  • Возвращать значение и логическое значение, указывающее, было ли переполнение, с помощью методов overflowing_*.
  • Насыщаться на минимальном или максимальном значении значения с помощью методов saturating_*.

Типы с плавающей точкой

В Rust также есть два примитивных типа для чисел с плавающей точкой, которые являются числами с десятичной точкой. Типы с плавающей точкой в Rust — это f32 и f64, размер которых составляет 32 бита и 64 бита соответственно. По умолчанию используется тип f64, потому что на современных процессорах он примерно такой же по скорости, как f32, но способен обеспечить большую точность. Все типы с плавающей точкой являются знаковыми.

Вот пример, демонстрирующий числа с плавающей точкой в действии:

Имя файла: src/main.rs

fn main() {
    let x = 2.0; // f64

    let y: f32 = 3.0; // f32
}

Числа с плавающей точкой представлены в соответствии со стандартом IEEE-754.

Числовые операции

Rust поддерживает базовые математические операции, которые вы ожидаете для всех числовых типов: сложение, вычитание, умножение, деление и остаток. Целочисленное деление усекает в сторону нуля до ближайшего целого числа. Следующий код показывает, как использовать каждую числовую операцию в операторе let:

Имя файла: src/main.rs

fn main() {
    // сложение
    let sum = 5 + 10;

    // вычитание
    let difference = 95.5 - 4.3;

    // умножение
    let product = 4 * 30;

    // деление
    let quotient = 56.7 / 32.2;
    let truncated = -5 / 3; // Результат: -1

    // остаток от деления
    let remainder = 43 % 5;
}

Каждое выражение в этих операторах использует математический оператор и вычисляется в одно значение, которое затем привязывается к переменной. Приложение B содержит список всех операторов, которые предоставляет Rust.

Логический тип

Как и в большинстве других языков программирования, логический тип в Rust имеет два возможных значения: true и false. Логические значения занимают один байт. Логический тип в Rust указывается с помощью bool. Например:

Имя файла: src/main.rs

fn main() {
    let t = true;

    let f: bool = false; // с явной аннотацией типа
}

Основной способ использования логических значений — через условные конструкции, такие как выражение if. Мы рассмотрим, как работают выражения if в Rust, в разделе «Поток управления».

Символьный тип

Тип char в Rust — это самый примитивный буквенный тип языка. Вот несколько примеров объявления значений char:

Имя файла: src/main.rs

fn main() {
    let c = 'z';
    let z: char = 'ℤ'; // с явной аннотацией типа
    let heart_eyed_cat = '😻';
}

Обратите внимание, что мы указываем литералы char с одинарными кавычками, в отличие от строковых литералов, которые используют двойные кавычки. Тип char в Rust занимает 4 байта и представляет скалярное значение Unicode, что означает, что он может представлять гораздо больше, чем просто ASCII. Буквы с диакритическими знаками; китайские, японские и корейские символы; эмодзи; и символы нулевой ширины — все это допустимые значения char в Rust. Скалярные значения Unicode находятся в диапазоне от U+0000 до U+D7FF и от U+E000 до U+10FFFF включительно. Однако «символ» на самом деле не является концепцией в Unicode, поэтому ваша человеческая интуиция о том, что такое «символ», может не совпадать с тем, что char в Rust. Мы подробно обсудим эту тему в разделе «Хранение текста в кодировке UTF-8 с помощью строк» в восьмой главе.

Составные типы

Составные типы могут группировать несколько значений в один тип. В Rust есть два примитивных составных типа: кортежи и массивы.

Тип кортеж

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

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

Имя файла: src/main.rs

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

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

Имя файла: src/main.rs

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {y}");
}

Эта программа сначала создаёт кортеж и привязывает его к переменной tup. Затем она использует шаблон с let, чтобы взять tup и превратить его в три отдельные переменные x, y и z. Это называется деструктуризацией, потому что она разбивает один кортеж на три части. Наконец, программа печатает значение y, которое равно 6.4.

Мы также можем получить доступ к элементу кортежа напрямую, используя точку (.), за которой следует индекс значения, к которому мы хотим получить доступ. Например:

Имя файла: src/main.rs

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0;

    let six_point_four = x.1;

    let one = x.2;
}

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

Кортеж без каких-либо значений имеет особое название — единица. Это значение и его соответствующий тип записываются как () и представляют пустое значение или пустой возвращаемый тип. Выражения неявно возвращают значение единицы, если они не возвращают никакого другого значения.

Тип массив

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

Мы записываем значения в массиве как разделённый запятыми список в квадратных скобках:

Имя файла: src/main.rs

fn main() {
    let a = [1, 2, 3, 4, 5];
}

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

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

#![allow(unused)]
fn main() {
let months = ["January", "February", "March", "April", "May", "June", "July",
              "August", "September", "October", "November", "December"];
}

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

#![allow(unused)]
fn main() {
let a: [i32; 5] = [1, 2, 3, 4, 5];
}

Здесь i32 — это тип каждого элемента. После точки с запятой число 5 указывает, что массив содержит пять элементов.

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

#![allow(unused)]
fn main() {
let a = [3; 5];
}

Массив с именем a будет содержать 5 элементов, все из которых изначально установлены в значение 3. Это то же самое, что написать let a = [3, 3, 3, 3, 3];, но более кратко.

Доступ к элементам массива

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

Имя файла: src/main.rs

fn main() {
    let a = [1, 2, 3, 4, 5];

    let first = a[0];
    let second = a[1];
}

В этом примере переменная с именем first получит значение 1, потому что это значение с индексом [0] в массиве. Переменная с именем second получит значение 2 из индекса [1] в массиве.

Недопустимый доступ к элементу массива

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

Имя файла: src/main.rs

use std::io;

fn main() {
    let a = [1, 2, 3, 4, 5];

    println!("Please enter an array index.");

    let mut index = String::new();

    io::stdin()
        .read_line(&mut index)
        .expect("Failed to read line");

    let index: usize = index
        .trim()
        .parse()
        .expect("Index entered was not a number");

    let element = a[index];

    println!("The value of the element at index {index} is: {element}");
}

Этот код успешно компилируется. Если вы запустите этот код с помощью cargo run и введёте 0, 1, 2, 3 или 4, программа выведет соответствующее значение по этому индексу в массиве. Если вы вместо этого введёте число за пределами массива, например 10, вы увидите примерно такой вывод:

thread 'main' panicked at src/main.rs:19:19:
index out of bounds: the len is 5 but the index is 10
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

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

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