Концепция владения в Rust на примерах

Перевод статьи «Rust Ownership by Example».

• Введение
• Право собственности начинается с переуступки
• С концом области видимости владение заканчивается
• Переназначение перемещает владение
• Копирование
• Заимствование
• Передача по ссылке или значению
• Заимствование и строковые литералы
• Возврат заимствованной величины
• Время жизни
• Время жизни и структуры
• Изменчивость
• MARSAW: несколько активных читателей или один активный писатель
• Заключение
• Послесловие переводчика

Введение

Rust – язык безопасного системного программирования. И хотя C и C++ тоже являются системными языками, но они небезопасны. В частности, Rust – это «типобезопасный язык», что означает, что компилятор гарантирует, что каждая программа имеет четко определенное поведение. Хотя есть языки, которые дают такую же гарантию, Rust делает это без сборщика мусора, среды выполнения или ручного управления памятью.

Ключевым моментом в гарантии безопасности языка Rust и его самой необычной особенностью является концепция владения. Наиболее частой проблемой программистов, осваивающих Rust, является проблема, связанная с концепцией владения. Освойте концепцию владения — и тогда Rust заиграет для вас всеми красками. Избегая концепции владения, вы будете бороться с компилятором даже при выполнении простых задач.

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

Запуск примеров кода и эксперименты очень полезны для изучения Rust. Самый простой способ сделать это – скопировать и вставить приведенные здесь примеры в веб-приложение Rust Playground (примечание переводчикаили онлайн-компилятор ideone.com). Если вы предпочитаете компилировать и запускать код на своем компьютере, самый простой способ сделать это – rustup.

Право собственности начинается с переуступки

Как и в других языках, Rust использует символ равенства «=» для присвоения значения переменной. Эта переменная описывает её дальнейшее использование.

Следующая программа присваивает переменной x значение 42, затем печатает значение x.

fn main() {
    let x = 42;

    println!("x: {}", x);
}

С концом области видимости владение заканчивается

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

Это правило позволяет легко получать ответ о времени жизни величины. Пока переменная остается в области видимости, принадлежащее ей значение всегда существует. Когда владение выйдет за рамки видимости, величина удаляется. Значение может быть удалено и задолго до конца области видимости, если компилятор видит, что переменная-владелец больше не используется.

Мы можем увидеть это правило воочию, назначив переменную в анонимной области видимости, созданной левой и правой фигурными скобками («{» и «}»):

fn main() {
    {
        let x = 42;
        println!("x: {}", x);
    }
    println!("x: {}", x); // ОШИБКА: x не в области видимости
}

8 |     println!("x: {}", x);
  |                       ^ не найден в этой области видимости

#[derive(Debug)]
struct DropMe;

impl Drop for DropMe {
    fn drop(&mut self) {
        println!("Dropping!");
    }
}

fn main() {
    println!("Begin outer scope."); {
        println!("Begin inner scope.");
        let x = DropMe;
        println!("x: {:?}", x);
    }
    println!("End outer scope.");
}

Begin outer scope.
Begin inner scope.
x: DropMe
Dropping!
End outer scope.

Переназначение перемещает владение

Если присвоение создаёт отношения собственности, то как насчет переназначения? Представьте, что мы хотим переназначить значение, принадлежащее a, новой переменной b:

fn main() {
    let a = vec![1, 2, 3]; // a — растущий литерал массива
    let b = a;        // перемещение: `a` не может больше использоваться
    println!("a: {:?}", b);
}

Векторы (также известные как Vec) – это растущие массивы Rust. Векторные литералы создаются с помощью функции-макроса vec!.

Этот код компилируется и запускается, выводя результат

a: [1, 2, 3].

Следуя правилу, согласно которому присвоение создает отношения собственности, мы ожидаем, что b станет новым владельцем. Учитывая, что у значения может быть только один владелец, мы также ожидаем, что a будет неинициализированным и, следовательно, непригодным для использования. Оба ожидания верны.

Передача права собственности (как в let b = a) известна как перемещение. Движение приводит к тому, что бывший правопреемник становится неинициализированным и, следовательно, не может использоваться в дальнейшем.

Мы можем подтвердить это, откомпилировав:

fn main() {
    let a = vec![1, 2, 3];
    let b = a;

    println!("a:{:?}\nb:{:?}", a, b); // ошибка: заимствование перемещённой 
				      // величины:`a`
}

Компилятор обнаруживает нашу попытку повторно использовать теперь уже неинициализированный a и жалуется:

2 |     let a = vec![1,2,3];
  |         - имеет место перемещение, потому что `a` имеет тип 
              `std::vec::Vec`, который не реализует типаж `Copy`
3 |     let b = a;
  |             - здесь величена перемещена
4 | 
5 |     println!("a:{:?}\nb:{:?}", a, b);
  |                                ^ здесь величина заимствована после перемещения

Это сообщение об ошибке немного сбивает с толку, предвидя то, что мы хотим сделать, и предлагая способ дальнейших действий. Позже мы перейдем к «заимствованию» и типажу Copy. А пока обратите внимание на ошибку в строке 5, которая была вызвана тем, что мы пытались получить доступ к a после перемещения.

Иногда бывает трудно заметить перемещение. Рассмотрим, что происходит, когда мы передаем аргумент функции:

fn sum(vector: Vec) -> i32 {
    let mut sum = 0; // изменчивость, подробности — позже
    for item in vector {
        sum = sum + item
    }
    sum
}

fn main() {
    let v = vec![1,2,3];
    let s = sum(v); // внимание, v был перемещён!
    println!("sum: {}", s);
}

Этот код компилируется и печатает результат sum: 6, как и ожидалось. Однако легко забыть о неявном перемещении, которое происходит при вызове sum. В частности, значение, принадлежащее v, перемещается в векторный параметр функции суммы.

Если бы мы использовали v после этого перемещения, то компилятор пожаловался бы:

fn sum(vector: Vec) -> i32 {
    let mut sum = 0;

    for item in vector {
        sum = sum + item
    }
    sum
}

fn main() {
    let v = vec![1,2,3];
    let s = sum(v);

    println!("sum of {:?}: {}", v, s); // ОШИБКА: v был перемещён!
}

Еще одна форма переназначения происходит при возврате значения из функции:

fn create_series(x: i32) -> Vec {
    let result = vec![x, x+1, x+2];

    result
}

fn main() {
    let series = create_series(42);

    println!("series: {:?}", series);
}

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

Копирование

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

fn sum(vector: Vec) -> i32 {
    let mut sum = 0;

    for item in vector {
        sum = sum + item
    }
    sum
}

fn main() {
    let v = vec![1,2,3];
    let s = sum(v);

    println!("sum of {:?}: {}", v, s); // ОШИБКА: v был перемещён!
}

fn sum(left: i32, right: i32) -> i32 {
    left + right
}

fn main() {
    let a = 42;
    let b = 1;
    let s = sum(a, b);

    println!("this sum of {} and {} is {}", a, b, s); // ошибки нет!
}

Вместо того чтобы перемещать значения, принадлежащие a и b, в параметры sum, значения копируются. Копия создает точную дубль значения, реализующего типаж Copy. В Rust числовые величины и некоторые другие «дешёвые» встроенные типы поддерживают копирование. Векторов нет.

Пример с Vec не может быть скомпилирован, потому что Vec не реализует типаж Copy. Пример с i32 успешен, потому что этот тип поддерживает копирование.

Это различие становится явным, когда переходим к пользовательским типам. Такие типы создаются из структуры. Например, мы можем определить тип Person:

#[derive(Debug)]
struct Person {
    age: i8
}

fn main() {
    let alice = Person { age: 42 };

    println!("alice: {:?}", alice);
}

Структуры не реализуют Copy по умолчанию. Переназначение величин типа Person приводит к перемещению, а не к копированию, как показано ниже:

#[derive(Debug)]
struct Person {
    age: i8
}

fn main() {
    let alice = Person { age: 42 };
    let bob = alice;

    println!("alice: {:?}\nbob: {:?}", alice, bob); // ОШИБКА: переменная
						    // alice перемещена
}

Однако мы можем преобразовать Person в тип, реализующий Copy. Для этого мы можем автоматически получить типаж Copy так же, как было получен типаж Debug. По причинам, выходящим за рамки данного руководства, также необходимо создать производный объект

Clone (Clone must also be derived).
#[derive(Debug,Clone,Copy)]
struct Person {
    age: i8
}

fn main() {
    let alice = Person { age: 42 };
    let bob = alice;

    println!("alice: {:?}\nbob: {:?}", alice, bob);
}

alice: Person { age: 42 }
bob: Person { age: 42 }

Здесь копирование работает для величин, подобных Person, которые можно эффективно скопировать, но как насчет «дорогих» значений?

Опубликовано: 2021.01.07, последняя правка: 2021.01.07    09:26

Добавить свой отзыв

Написать автору можно на электронную почту
mail(аt)compiler.su