Ссылки и заимствование
Проблема с кодом кортежа в листинге 4-5 заключается в том, что нам приходится возвращать
String вызывающей функции, чтобы мы могли по-прежнему использовать String после
вызова calculate_length, потому что String была перемещена в
calculate_length. Вместо этого мы можем передать ссылку на значение String.
Ссылка подобна указателю в том смысле, что это адрес, по которому мы можем перейти для доступа
к данным, хранящимся по этому адресу; эти данные принадлежат какой-то другой переменной.
В отличие от указателя, ссылка гарантированно указывает на допустимое значение
определённого типа в течение времени жизни этой ссылки.
Вот как можно определить и использовать функцию calculate_length, которая имеет
ссылку на объект в качестве параметра вместо того, чтобы принимать владение значением:
fn main() {
let s1 = String::from("hello");
let len = calculate_length(&s1);
println!("The length of '{s1}' is {len}.");
}
fn calculate_length(s: &String) -> usize {
s.len()
}
Во-первых, обратите внимание, что весь код кортежа в объявлении переменной и
возвращаемом значении функции исчез. Во-вторых, обратите внимание, что мы передаём &s1 в
calculate_length и в её определении принимаем &String, а не
String. Эти амперсанды представляют ссылки, и они позволяют вам ссылаться на
некоторое значение, не принимая владение им. На рисунке 4-6 изображена эта концепция.
Рисунок 4-6: Диаграмма &String s, указывающей на
String s1
Примечание: Противоположностью создания ссылки с помощью & является разыменование, которое
выполняется с помощью оператора разыменования *. Мы увидим некоторые применения
оператора разыменования в восьмой главе и обсудим детали разыменования в
пятнадцатой главе.
Давайте подробнее рассмотрим вызов функции здесь:
fn main() {
let s1 = String::from("hello");
let len = calculate_length(&s1);
println!("The length of '{s1}' is {len}.");
}
fn calculate_length(s: &String) -> usize {
s.len()
}
Синтаксис &s1 позволяет нам создать ссылку, которая ссылается на значение s1,
но не владеет им. Поскольку ссылка не владеет им, значение, на которое она указывает,
не будет освобождено, когда ссылка перестанет использоваться.
Аналогично, сигнатура функции использует &, чтобы указать, что тип
параметра s является ссылкой. Давайте добавим некоторые поясняющие аннотации:
fn main() {
let s1 = String::from("hello");
let len = calculate_length(&s1);
println!("The length of '{s1}' is {len}.");
}
fn calculate_length(s: &String) -> usize { // s — это ссылка на String
s.len()
} // Здесь s выходит из области видимости. Но поскольку s не владеет тем,
// на что указывает, String не удаляется.
Область видимости, в которой переменная s действительна, такая же, как у любого параметра
функции, но значение, на которое указывает ссылка, не освобождается,
когда s перестаёт использоваться, потому что s не владеет им. Когда функции
имеют ссылки в качестве параметров вместо фактических значений, нам не нужно
возвращать значения, чтобы вернуть владение, потому что мы никогда им не владели.
Мы называем действие создания ссылки заимствованием. Как и в реальной жизни, если человек владеет чем-то, вы можете занять это у него. Когда вы закончите, вы должны вернуть это. Вы не владеете этим.
Итак, что произойдёт, если мы попытаемся изменить то, что мы заимствуем? Попробуйте код в листинге 4-6. Спойлер: это не сработает!
fn main() {
let s = String::from("hello");
change(&s);
}
fn change(some_string: &String) {
some_string.push_str(", world");
}
Вот ошибка:
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0596]: cannot borrow `*some_string` as mutable, as it is behind a `&` reference
--> src/main.rs:8:5
|
8 | some_string.push_str(", world");
| ^^^^^^^^^^^ `some_string` is a `&` reference, so it cannot be borrowed as mutable
|
help: consider changing this to be a mutable reference
|
7 | fn change(some_string: &mut String) {
| +++
For more information about this error, try `rustc --explain E0596`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error
Подобно тому, как переменные по умолчанию неизменяемы, ссылки тоже. Нам не разрешено изменять то, на что у нас есть ссылка.
Изменяемые ссылки
Мы можем исправить код из листинга 4-6, чтобы разрешить нам изменять заимствованное значение, всего с несколькими небольшими изменениями, которые используют вместо этого изменяемую ссылку:
fn main() {
let mut s = String::from("hello");
change(&mut s);
}
fn change(some_string: &mut String) {
some_string.push_str(", world");
}
Сначала мы меняем s на mut. Затем мы создаём изменяемую ссылку с помощью
&mut s там, где вызываем функцию change, и обновляем сигнатуру функции,
чтобы она принимала изменяемую ссылку с помощью some_string: &mut String. Это делает
очень ясным, что функция change будет изменять значение, которое она заимствует.
Изменяемые ссылки имеют одно большое ограничение: если у вас есть изменяемая ссылка на
значение, у вас не может быть никаких других ссылок на это значение. Этот код, который
пытается создать две изменяемые ссылки на s, не сработает:
fn main() {
let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s;
println!("{r1}, {r2}");
}
Вот ошибка:
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0499]: cannot borrow `s` as mutable more than once at a time
--> src/main.rs:5:14
|
4 | let r1 = &mut s;
| ------ first mutable borrow occurs here
5 | let r2 = &mut s;
| ^^^^^^ second mutable borrow occurs here
6 |
7 | println!("{r1}, {r2}");
| -- first borrow later used here
For more information about this error, try `rustc --explain E0499`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error
Эта ошибка говорит, что этот код недопустим, потому что мы не можем заимствовать s как
изменяемую более одного раза одновременно. Первое изменяемое заимствование находится в r1 и должно
длиться до тех пор, пока оно используется в println!, но между созданием этой
изменяемой ссылки и её использованием мы попытались создать другую изменяемую ссылку
в r2, которая заимствует те же данные, что и r1.
Ограничение, предотвращающее множественные изменяемые ссылки на одни и те же данные в одно и то же время, позволяет изменять, но очень контролируемым образом. Это то, с чем новички в Rust борются, потому что большинство языков позволяют изменять когда угодно. Преимущество этого ограничения в том, что Rust может предотвращать гонки данных во время компиляции. Гонка данных похожа на состояние гонки и происходит, когда имеют место эти три поведения:
- Два или более указателя обращаются к одним и тем же данным одновременно.
- По крайней мере один из указателей используется для записи в данные.
- Не используется никакого механизма для синхронизации доступа к данным.
Гонки данных вызывают неопределённое поведение и могут быть трудными для диагностики и исправления, когда вы пытаетесь отследить их во время выполнения; Rust предотвращает эту проблему, отказываясь компилировать код с гонками данных!
Как всегда, мы можем использовать фигурные скобки для создания новой области видимости, что позволяет использовать несколько изменяемых ссылок, но не одновременных:
fn main() {
let mut s = String::from("hello");
{
let r1 = &mut s;
} // r1 здесь выходит из области видимости, поэтому мы можем без проблем создать новую ссылку.
let r2 = &mut s;
}
Rust применяет аналогичное правило для комбинирования изменяемых и неизменяемых ссылок. Этот код приводит к ошибке:
fn main() {
let mut s = String::from("hello");
let r1 = &s; // никаких проблем
let r2 = &s; // никаких проблем
let r3 = &mut s; // БОЛЬШАЯ ПРОБЛЕМА
println!("{r1}, {r2}, and {r3}");
}
Вот ошибка:
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
--> src/main.rs:6:14
|
4 | let r1 = &s; // no problem
| -- immutable borrow occurs here
5 | let r2 = &s; // no problem
6 | let r3 = &mut s; // BIG PROBLEM
| ^^^^^^ mutable borrow occurs here
7 |
8 | println!("{r1}, {r2}, and {r3}");
| -- immutable borrow later used here
For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error
Ух! Мы также не можем иметь изменяемую ссылку, пока у нас есть неизменяемая на то же значение.
Пользователи неизменяемой ссылки не ожидают, что значение внезапно изменится у них на глазах! Однако множественные неизменяемые ссылки разрешены, потому что никто, кто просто читает данные, не имеет возможности повлиять на чужое чтение данных.
Обратите внимание, что область видимости ссылки начинается с того места, где она введена, и продолжается
до последнего момента, когда эта ссылка используется. Например, этот код
скомпилируется, потому что последнее использование неизменяемых ссылок находится в println!,
до введения изменяемой ссылки:
fn main() {
let mut s = String::from("hello");
let r1 = &s; // никаких проблем
let r2 = &s; // никаких проблем
println!("{r1} and {r2}");
// Переменные r1 и r2 не будут использоваться после этого места.
let r3 = &mut s; // никаких проблем
println!("{r3}");
}
Области видимости неизменяемых ссылок r1 и r2 заканчиваются после println!,
где они используются в последний раз, что происходит до создания изменяемой ссылки r3.
Эти области видимости не перекрываются, поэтому этот код разрешён: компилятор может
определить, что ссылка больше не используется в точке до конца
области видимости.
Хотя ошибки заимствования иногда могут раздражать, помните, что это компилятор Rust указывает на потенциальную ошибку заранее (во время компиляции, а не во время выполнения) и показывает вам точно, где проблема. Тогда вам не нужно отслеживать, почему ваши данные не такие, как вы думали.
Висячие ссылки
В языках с указателями легко ошибочно создать висячий указатель — указатель, который ссылается на местоположение в памяти, которое могло быть отдано кому-то другому, — освободив некоторую память, сохраняя указатель на эту память. В Rust, напротив, компилятор гарантирует, что ссылки никогда не будут висячими: если у вас есть ссылка на некоторые данные, компилятор обеспечит, что данные не выйдут из области видимости до того, как это сделает ссылка на данные.
Давайте попробуем создать висячую ссылку, чтобы увидеть, как Rust предотвращает их с помощью ошибки времени компиляции:
fn main() {
let reference_to_nothing = dangle();
}
fn dangle() -> &String {
let s = String::from("hello");
&s
}
Вот ошибка:
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0106]: missing lifetime specifier
--> src/main.rs:5:16
|
5 | fn dangle() -> &String {
| ^ expected named lifetime parameter
|
= help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
|
5 | fn dangle() -> &'static String {
| +++++++
help: instead, you are more likely to want to return an owned value
|
5 - fn dangle() -> &String {
5 + fn dangle() -> String {
|
For more information about this error, try `rustc --explain E0106`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error
Это сообщение об ошибке ссылается на функцию, которую мы ещё не рассматривали: времена жизни. Мы подробно обсудим времена жизни в десятой главе. Но если вы проигнорируете части о временах жизни, сообщение содержит ключ к тому, почему этот код является проблемой:
this function's return type contains a borrowed value, but there is no value
for it to be borrowed from
Давайте более внимательно рассмотрим, что именно происходит на каждом этапе нашего
кода dangle:
fn main() {
let reference_to_nothing = dangle();
}
fn dangle() -> &String { // dangle возвращает ссылку на String
let s = String::from("hello"); // s — новая строка String
&s // мы возвращаем ссылку на String, s
} // Здесь s выходит из области видимости и удаляется, поэтому её память освобождается.
// Опасность!
Поскольку s создаётся внутри dangle, когда код dangle завершается,
s будет освобождён. Но мы попытались вернуть ссылку на него. Это означает,
что эта ссылка указывала бы на недопустимую String. Это никуда не годится! Rust
не позволит нам это сделать.
Решение здесь — вернуть String напрямую:
fn main() {
let string = no_dangle();
}
fn no_dangle() -> String {
let s = String::from("hello");
s
}
Это работает без каких-либо проблем. Владение перемещается наружу, и ничего не освобождается.
Правила ссылок
Давайте подведём итог тому, что мы обсудили о ссылках:
- В любой момент времени у вас может быть либо одна изменяемая ссылка, либо любое количество неизменяемых ссылок.
- Ссылки всегда должны быть действительными.
Далее мы рассмотрим другой вид ссылки: срезы.