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

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

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

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

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

Использование Box<T> для указания на данные в куче

Самый простой умный указатель — это бокс, тип которого записывается как Box<T>. Боксы позволяют хранить данные в куче, а не в стеке. Что остаётся в стеке — это указатель на данные в куче. Обратитесь к главе 4, чтобы вспомнить разницу между стеком и кучей.

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

  • Когда у вас есть тип, размер которого не может быть известен во время компиляции, и вы хотите использовать значение этого типа в контексте, требующем точного размера
  • Когда у вас есть большой объём данных и вы хотите передать владение, но гарантировать, что данные не будут скопированы при этом
  • Когда вы хотите владеть значением и вас заботит только то, что это тип, реализующий определённый трейт, а не конкретный тип

Мы продемонстрируем первую ситуацию в «Включение рекурсивных типов с помощью боксов». Во второй случае передача владения большим объёмом данных может занять много времени, потому что данные копируются в стеке. Чтобы улучшить производительность в этой ситуации, мы можем сохранить большой объём данных в куче в боксе. Затем только небольшой объём данных указателя копируется в стеке, в то время как данные, на которые он ссылается, остаются на одном месте в куче. Третий случай известен как трейт-объект, и «Использование трейт-объектов для абстрагирования над общим поведением» в главе 18 посвящена этой теме. Так что то, что вы узнаете здесь, вы примените снова в том разделе!

Хранение данных в куче

Прежде чем мы обсудим вариант использования Box<T> для хранения в куче, мы рассмотрим синтаксис и то, как взаимодействовать со значениями, хранящимися внутри Box<T>.

Листинг 15-1 показывает, как использовать бокс для хранения значения i32 в куче.

Имя файла: src/main.rs
fn main() {
    let b = Box::new(5);
    println!("b = {b}");
}
Листинг 15-1: Хранение значения i32 в куче с помощью бокса

Мы определяем переменную b со значением Box, которое указывает на значение 5, размещённое в куче. Эта программа напечатает b = 5; в этом случае мы можем получить доступ к данным в боксе аналогично тому, как мы бы это делали, если бы эти данные были в стеке. Как и любое принадлежащее значение, когда бокс выходит из области видимости, как b в конце main, он будет освобождён. Освобождение происходит как для бокса (хранящегося в стеке), так и для данных, на которые он указывает (хранящихся в куче).

Помещение одного значения в кучу не очень полезно, поэтому вы не будете использовать боксы сами по себе таким образом очень часто. Наличие значений, таких как один i32, в стеке, где они хранятся по умолчанию, более уместно в большинстве ситуаций. Давайте рассмотрим случай, когда боксы позволяют нам определять типы, которые мы не могли бы определить, если бы у нас не было боксов.

Включение рекурсивных типов с помощью боксов

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

В качестве примера рекурсивного типа давайте исследуем cons-список. Это тип данных, обычно встречающийся в функциональных языках программирования. Тип cons-списка, который мы определим, прост, за исключением рекурсии; поэтому концепции в примере, с которым мы будем работать, будут полезны всякий раз, когда вы столкнётесь с более сложными ситуациями, связанными с рекурсивными типами.

Понимание cons-списка

Cons-список — это структура данных, происходящая из языка программирования Lisp и его диалектов, состоящая из вложенных пар, и является версией связного списка в Lisp. Его название происходит от функции cons (сокращение от construct function) в Lisp, которая создаёт новую пару из двух своих аргументов. Вызывая cons на паре, состоящей из значения и другой пары, мы можем построить cons-списки, состоящие из рекурсивных пар.

Например, вот псевдокодовое представление cons-списка, содержащего список 1, 2, 3, где каждая пара в скобках:

(1, (2, (3, Nil)))

Каждый элемент в cons-списке содержит два элемента: значение текущего элемента и следующего элемента. Последний элемент в списке содержит только значение под названием Nil без следующего элемента. Cons-список создаётся путём рекурсивного вызова функции cons. Каноническое имя для обозначения базового случая рекурсии — Nil. Обратите внимание, что это не то же самое, что понятие «null» или «nil», обсуждавшееся в главе 6, которое является недопустимым или отсутствующим значением.

Cons-список не является часто используемой структурой данных в Rust. В большинстве случаев, когда у вас есть список элементов в Rust, Vec<T> — лучший выбор для использования. Другие, более сложные рекурсивные типы данных являются полезными в различных ситуациях, но начав с cons-списка в этой главе, мы можем исследовать, как боксы позволяют нам определить рекурсивный тип данных без особых отвлечений.

Листинг 15-2 содержит определение перечисления для cons-списка. Обратите внимание, что этот код пока не скомпилируется, потому что тип List не имеет известного размера, что мы продемонстрируем.

Имя файла: src/main.rs
enum List {
    Cons(i32, List),
    Nil,
}

fn main() {}
Листинг 15-2: Первая попытка определить перечисление для представления структуры данных cons-списка значений i32

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

Использование типа List для хранения списка 1, 2, 3 выглядело бы как код в листинге 15-3.

Имя файла: src/main.rs
enum List {
    Cons(i32, List),
    Nil,
}

// --snip--

use crate::List::{Cons, Nil};

fn main() {
    let list = Cons(1, Cons(2, Cons(3, Nil)));
}
Листинг 15-3: Использование перечисления List для хранения списка 1, 2, 3

Первое значение Cons содержит 1 и другое значение List. Это значение List — другое значение Cons, которое содержит 2 и другое значение List. Это значение List — ещё одно значение Cons, которое содержит 3 и значение List, которое, наконец, является Nil, нерекурсивным вариантом, сигнализирующим о конце списка.

Если мы попытаемся скомпилировать код в листинге 15-3, мы получим ошибку, показанную в листинге 15-4.

$ cargo run
   Compiling cons-list v0.1.0 (file:///projects/cons-list)
error[E0072]: recursive type `List` has infinite size
 --> src/main.rs:1:1
  |
1 | enum List {
  | ^^^^^^^^^
2 |     Cons(i32, List),
  |               ---- recursive without indirection
  |
help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
  |
2 |     Cons(i32, Box<List>),
  |               ++++    +

For more information about this error, try `rustc --explain E0072`.
error: could not compile `cons-list` (bin "cons-list") due to 1 previous error
Листинг 15-4: Ошибка, которую мы получаем при попытке определить рекурсивное перечисление

Ошибка показывает, что этот тип «имеет бесконечный размер». Причина в том, что мы определили List с вариантом, который является рекурсивным: он содержит другое значение самого себя напрямую. В результате Rust не может определить, сколько места нужно для хранения значения List. Давайте разберём, почему мы получаем эту ошибку. Сначала мы рассмотрим, как Rust решает, сколько места нужно для хранения значения нерекурсивного типа.

Вычисление размера нерекурсивного типа

Вспомните перечисление Message, которое мы определили в листинге 6-2, когда обсуждали определения перечислений в главе 6:

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {}

Чтобы определить, сколько места выделить для значения Message, Rust просматривает каждый из вариантов, чтобы увидеть, какой вариант требует больше всего места. Rust видит, что Message::Quit не требует места, Message::Move требует достаточно места для хранения двух значений i32, и так далее. Поскольку будет использоваться только один вариант, наибольшее пространство, которое потребуется значению Message, — это пространство, которое потребовалось бы для хранения наибольшего из его вариантов.

Сравните это с тем, что происходит, когда Rust пытается определить, сколько места нужно рекурсивному типу, такому как перечисление List в листинге 15-2. Компилятор начинает с просмотра варианта Cons, который содержит значение типа i32 и значение типа List. Следовательно, Cons требует объём пространства, равный размеру i32 плюс размер List. Чтобы выяснить, сколько памяти нужно типу List, компилятор смотрит на варианты, начиная с варианта Cons. Вариант Cons содержит значение типа i32 и значение типа List, и этот процесс продолжается бесконечно, как показано на Рисунке 15-1.

Бесконечный Cons-список: прямоугольник с меткой 'Cons', разделённый на два меньших прямоугольника. Первый меньший прямоугольник содержит метку 'i32', а второй меньший прямоугольник содержит метку 'Cons' и меньшую версию внешнего прямоугольника 'Cons'. Прямоугольники 'Cons' продолжают содержать всё меньшие и меньшие версии самих себя, пока самый маленький прямоугольник удобного размера не содержит символ бесконечности, указывая, что это повторение продолжается бесконечно.

Рисунок 15-1: Бесконечный List, состоящий из бесконечных вариантов Cons

Получение рекурсивного типа с известным размером

Поскольку Rust не может определить, сколько места выделить для рекурсивно определённых типов, компилятор выдаёт ошибку с этим полезным предложением:

help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
  |
2 |     Cons(i32, Box<List>),
  |               ++++    +

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

Поскольку Box<T> является указателем, Rust всегда знает, сколько места нужно Box<T>: размер указателя не меняется в зависимости от объёма данных, на которые он указывает. Это означает, что мы можем поместить Box<T> в вариант Cons вместо другого значения List напрямую. Box<T> будет указывать на следующее значение List, которое будет в куче, а не внутри варианта Cons. Концептуально у нас всё ещё есть список, созданный из списков, содержащих другие списки, но эта реализация теперь больше похожа на размещение элементов рядом друг с другом, а не внутри друг друга.

Мы можем изменить определение перечисления List в листинге 15-2 и использование List в листинге 15-3 на код в листинге 15-5, который скомпилируется.

Имя файла: src/main.rs
enum List {
    Cons(i32, Box<List>),
    Nil,
}

use crate::List::{Cons, Nil};

fn main() {
    let list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil))))));
}
Листинг 15-5: Определение List, которое использует Box<T>, чтобы иметь известный размер

Варианту Cons нужен размер i32 плюс пространство для хранения данных указателя бокса. Вариант Nil не хранит значений, поэтому ему нужно меньше места в стеке, чем варианту Cons. Теперь мы знаем, что любое значение List займёт размер i32 плюс размер данных указателя бокса. Используя бокс, мы разорвали бесконечную рекурсивную цепочку, поэтому компилятор может определить размер, необходимый для хранения значения List. Рисунок 15-2 показывает, как выглядит вариант Cons теперь.

Прямоугольник с меткой 'Cons', разделённый на два меньших прямоугольника. Первый меньший прямоугольник содержит метку 'i32', а второй меньший прямоугольник содержит метку 'Box' с одним внутренним прямоугольником, который содержит метку 'usize', представляя конечный размер указателя бокса.

Рисунок 15-2: List, который не имеет бесконечного размера, потому что Cons содержит Box

Боксы обеспечивают только косвенность и выделение в куче; у них нет никаких других особых возможностей, подобных тем, которые мы увидим с другими типами умных указателей. Они также не имеют накладных расходов на производительность, которые влекут за собой эти особые возможности, поэтому они могут быть полезны в случаях, подобных cons-списку, где косвенность — единственная необходимая нам функция. Мы рассмотрим больше вариантов использования боксов в главе 18.

Тип Box<T> является умным указателем, потому что он реализует трейт Deref, который позволяет обращаться со значениями Box<T> как со ссылками. Когда значение Box<T> выходит из области видимости, данные в куче, на которые указывает бокс, также очищаются благодаря реализации трейта Drop. Эти два трейта будут ещё более важны для функциональности, предоставляемой другими типами умных указателей, которые мы обсудим в оставшейся части этой главы. Давайте рассмотрим эти два трейта более подробно.