Хранение списков значений с помощью векторов
Первый тип коллекции, который мы рассмотрим, — это Vec<T>, также известный как вектор.
Векторы позволяют хранить более одного значения в единой структуре данных, размещая
все значения рядом друг с другом в памяти. Векторы могут хранить значения только
одного типа. Они полезны, когда есть список элементов, например строки
текста в файле или цены товаров в корзине покупок.
Создание нового вектора
Чтобы создать новый пустой вектор, вызывается функция Vec::new, как показано в
листинге 8-1.
fn main() {
let v: Vec<i32> = Vec::new();
}
i32Обратите внимание, что здесь добавлена аннотация типа. Поскольку в этот вектор
не вставляются никакие значения, Rust не знает, элементы какого типа
предполагается хранить. Это важный момент. Векторы реализованы с использованием
обобщённых типов; как использовать обобщённые типы с собственными типами, мы
рассмотрим в главе 10. Пока достаточно знать, что тип Vec<T>, предоставляемый
стандартной библиотекой, может хранить любой тип. Когда создаётся вектор для
хранения конкретного типа, тип можно указать в угловых скобках. В листинге 8-1
мы сообщили Rust, что Vec<T> в v будет хранить элементы типа
i32.
Чаще создаётся Vec<T> с начальными значениями, и Rust выводит
тип значений, которые предполагается хранить, поэтому такая аннотация
типа требуется редко. Rust удобно предоставляет макрос vec!, который создаёт
новый вектор с указанными значениями. Листинг 8-2 создаёт новый
Vec<i32>, содержащий значения 1, 2 и 3. Тип целых чисел — i32,
потому что это тип целых чисел по умолчанию, как обсуждалось в разделе «Типы
данных» главы 3.
fn main() {
let v = vec![1, 2, 3];
}
Поскольку заданы начальные значения i32, Rust может вывести, что тип v
— это Vec<i32>, и аннотация типа не нужна. Далее рассмотрим, как
изменять вектор.
Обновление вектора
Чтобы создать вектор, а затем добавить в него элементы, можно использовать метод push,
как показано в листинге 8-3.
fn main() {
let mut v = Vec::new();
v.push(5);
v.push(6);
v.push(7);
v.push(8);
}
push для добавления значений в векторКак и для любой переменной, если требуется иметь возможность изменять её значение,
её нужно сделать изменяемой с помощью ключевого слова mut, как обсуждалось в главе 3. Числа,
которые мы помещаем внутрь, все имеют тип i32, и Rust выводит это из данных, поэтому
аннотация Vec<i32> не нужна.
Чтение элементов векторов
Есть два способа сослаться на значение, хранящееся в векторе: с помощью индексации или
метода get. В следующих примерах мы аннотировали типы
значений, возвращаемых этими функциями, для дополнительной ясности.
Листинг 8-4 показывает оба способа доступа к значению в векторе: синтаксис индексации
и метод get.
fn main() {
let v = vec![1, 2, 3, 4, 5];
let third: &i32 = &v[2];
println!("The third element is {third}");
let third: Option<&i32> = v.get(2);
match third {
Some(third) => println!("The third element is {third}"),
None => println!("There is no third element."),
}
}
get для доступа к элементу вектораОбратите внимание на несколько деталей. Мы используем индекс 2, чтобы получить третий элемент,
потому что векторы индексируются числами, начиная с нуля. Использование & и []
даёт нам ссылку на элемент по значению индекса. Когда мы используем метод get
с индексом, переданным в качестве аргумента, мы получаем Option<&T>, который можно
использовать с match.
Rust предоставляет эти два способа ссылки на элемент, чтобы можно было выбрать, как программа будет себя вести при попытке использовать значение индекса за пределами диапазона существующих элементов. В качестве примера посмотрим, что произойдёт, если у нас есть вектор из пяти элементов и мы попытаемся получить доступ к элементу с индексом 100 каждым из способов, как показано в листинге 8-5.
fn main() {
let v = vec![1, 2, 3, 4, 5];
let does_not_exist = &v[100];
let does_not_exist = v.get(100);
}
Когда мы запускаем этот код, первый способ с [] вызовет панику программы,
потому что он ссылается на несуществующий элемент. Этот способ лучше использовать, когда
нужно, чтобы программа аварийно завершилась при попытке доступа к элементу за
пределами вектора.
Когда методу get передаётся индекс за пределами вектора, он возвращает
None без паники. Этот способ следует использовать, если доступ к элементу
за пределами диапазона вектора может происходить время от времени при нормальных
обстоятельствах. Затем в коде будет логика обработки как
Some(&element), так и None, как обсуждалось в главе 6. Например, индекс
может поступать от человека, вводящего число. Если он случайно введёт
слишком большое число и программа получит значение None, можно сообщить
пользователю, сколько элементов в текущем векторе, и дать ему ещё одну попытку
ввести корректное значение. Это было бы удобнее для пользователя, чем аварийное завершение программы
из-за опечатки!
Когда программа имеет корректную ссылку, проверка заимствований обеспечивает соблюдение правил владения и заимствования (рассмотренных в главе 4), чтобы гарантировать, что эта ссылка и любые другие ссылки на содержимое вектора остаются корректными. Вспомните правило, согласно которому нельзя иметь изменяемые и неизменяемые ссылки в одной области видимости. Это правило применимо в листинге 8-6, где мы держим неизменяемую ссылку на первый элемент вектора и пытаемся добавить элемент в конец. Эта программа не будет работать, если мы также попытаемся обратиться к этому элементу позже в функции.
fn main() {
let mut v = vec![1, 2, 3, 4, 5];
let first = &v[0];
v.push(6);
println!("The first element is: {first}");
}
Компиляция этого кода приведёт к следующей ошибке:
$ cargo run
Compiling collections v0.1.0 (file:///projects/collections)
error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
--> src/main.rs:6:5
|
4 | let first = &v[0];
| - immutable borrow occurs here
5 |
6 | v.push(6);
| ^^^^^^^^^ mutable borrow occurs here
7 |
8 | println!("The first element is: {first}");
| ----- immutable borrow later used here
For more information about this error, try `rustc --explain E0502`.
error: could not compile `collections` (bin "collections") due to 1 previous error
Код в листинге 8-6 может показаться работающим: почему ссылка на первый элемент должна зависеть от изменений в конце вектора? Эта ошибка обусловлена тем, как работают векторы: поскольку векторы размещают значения рядом друг с другом в памяти, добавление нового элемента в конец вектора может потребовать выделения новой памяти и копирования старых элементов в новое пространство, если не хватает места, чтобы разместить все элементы рядом друг с другом там, где вектор сейчас хранится. В этом случае ссылка на первый элемент указывала бы на освобождённую память. Правила заимствования не позволяют программам оказаться в такой ситуации.
Примечание: Подробнее о деталях реализации типа Vec<T> см. «The
Rustonomicon».
Перебор значений в векторе
Чтобы поочерёдно получить доступ к каждому элементу вектора, нужно перебрать все
элементы, а не использовать индексы для доступа к ним по одному. Листинг 8-7 показывает, как
использовать цикл for для получения неизменяемых ссылок на каждый элемент вектора
значений i32 и их вывода.
fn main() {
let v = vec![100, 32, 57];
for i in &v {
println!("{i}");
}
}
forМожно также перебирать изменяемые ссылки на каждый элемент изменяемого вектора,
чтобы вносить изменения во все элементы. Цикл for в листинге 8-8
добавит 50 к каждому элементу.
fn main() {
let mut v = vec![100, 32, 57];
for i in &mut v {
*i += 50;
}
}
Чтобы изменить значение, на которое ссылается изменяемая ссылка, нужно использовать
оператор разыменования *, чтобы добраться до значения в i, прежде чем применять
оператор +=. Подробнее об операторе разыменования пойдёт речь в разделе «Следование
по ссылке к значению» главы 15.
Перебор вектора, как неизменяемый, так и изменяемый, безопасен благодаря
правилам проверки заимствований. Если бы мы попытались вставить или удалить элементы в теле цикла for
в листингах 8-7 и 8-8, мы получили бы ошибку компиляции,
аналогичную той, что была получена с кодом из листинга 8-6. Ссылка на
вектор, которую держит цикл for, предотвращает одновременное изменение
всего вектора.
Использование перечисления для хранения нескольких типов
Векторы могут хранить только значения одного и того же типа. Это может быть неудобно; определённо есть случаи, когда нужно хранить список элементов разных типов. К счастью, варианты перечисления определяются в рамках одного типа перечисления, поэтому, когда нужен один тип для представления элементов разных типов, можно определить и использовать перечисление!
Например, предположим, что мы хотим получить значения из строки электронной таблицы, в которой некоторые столбцы строки содержат целые числа, некоторые — числа с плавающей запятой, а некоторые — строки. Можно определить перечисление, варианты которого будут содержать разные типы значений, и все варианты перечисления будут считаться одним типом: типом перечисления. Затем можно создать вектор для хранения этого перечисления и, следовательно, хранить разные типы. Мы продемонстрировали это в листинге 8-9.
fn main() {
enum SpreadsheetCell {
Int(i32),
Float(f64),
Text(String),
}
let row = vec![
SpreadsheetCell::Int(3),
SpreadsheetCell::Text(String::from("blue")),
SpreadsheetCell::Float(10.12),
];
}
Rust нужно знать, какие типы будут в векторе, во время компиляции, чтобы знать,
сколько памяти в куче потребуется для хранения каждого элемента.
Также нужно явно указать, какие типы разрешены в этом векторе. Если бы Rust
позволял вектору хранить любой тип, была бы вероятность, что один или несколько
типов вызовут ошибки при выполнении операций над элементами
вектора. Использование перечисления в сочетании с выражением match означает, что Rust гарантирует
во время компиляции обработку всех возможных случаев, как обсуждалось в главе 6.
Если неизвестен полный набор типов, которые программа получит во время выполнения для хранения в векторе, метод с перечислением не сработает. Вместо этого можно использовать трейт-объект, который мы рассмотрим в главе 18.
Теперь, когда мы обсудили некоторые из наиболее распространённых способов использования векторов, обязательно
ознакомьтесь с документацией по API для всех многих
полезных методов, определённых для Vec<T> стандартной библиотекой. Например, помимо
push, метод pop удаляет и возвращает последний элемент.
Удаление вектора удаляет его элементы
Как и любая другая struct, вектор освобождается, когда выходит из области видимости, как
отмечено в листинге 8-10.
fn main() {
{
let v = vec![1, 2, 3, 4];
// делаем что-то с v
} // <- v выходит из области видимости и освобождается здесь
}
Когда вектор удаляется, всё его содержимое также удаляется, то есть хранящиеся в нём целые числа очищаются. Проверка заимствований гарантирует, что любые ссылки на содержимое вектора используются только пока сам вектор корректен.
Перейдём к следующему типу коллекции: String!