Ownership

Ownership — набор из трёх правил, проверяемых компилятором: (1) у каждого значения есть переменная-владелец; (2) владелец в любой момент времени ровно один; (3) когда владелец выходит из области видимости, значение уничтожается (вызывается Drop::drop, если он реализован). Присваивание владеющего значения (не ссылки) другой переменной — это move: старая переменная становится недействительной, компилятор запрещает её дальнейшее использование.Ownership is a set of three rules checked by the compiler: (1) every value has an owning variable; (2) there is exactly one owner at any given time; (3) when the owner goes out of scope, the value is dropped (Drop::drop runs, if implemented). Assigning an owning value (not a reference) to another variable is a move: the old variable becomes invalid, and the compiler forbids using it afterward.

std::vector<int> a = {1, 2, 3};
std::vector<int> b = a;  // глубокая копия — легально, но может быть случайной// a deep copy — legal, but can happen by accident
a.push_back(4);         // a по-прежнему валиден, компилятор не проверяет "кто владеет"// a is still valid — the compiler tracks no notion of "who owns this"

let a = vec![1, 2, 3];
let b = a;              // move — владение переходит к b, не копия// a move — ownership transfers to b, not a copy
a.push(4);            // ОШИБКА КОМПИЛЯЦИИ: use of moved value: `a`// COMPILE ERROR: use of moved value: `a`

Ownership решает задачу управления памятью, для которой раньше существовало только два неудовлетворительных ответа:Ownership solves a memory-management problem that previously had only two unsatisfying answers:

Move в Rust — это чисто статический, compile-time механизм: физически при перемещении String или Vec<T> происходит побитовое копирование их внутренней структуры (указатель на буфер, длина, capacity) в новую переменную — ровно как memcpy. Разница со случайным дублированием в том, что компилятор помечает старую переменную как "перемещённую" в своей внутренней модели потока данных (borrow checker) и статически запрещает любое обращение к ней дальше по коду — независимо от того, идёт ли речь об одном пути исполнения или о ветвлении.A move in Rust is a purely static, compile-time mechanism: physically, moving a String or Vec<T> performs a bitwise copy of their internal structure (a pointer to the buffer, length, capacity) into the new variable — exactly like memcpy. The difference from accidental duplication is that the compiler marks the old variable as "moved" in its internal data-flow model (the borrow checker) and statically forbids any further access to it — regardless of whether that's a single execution path or a branch.

fn takes_ownership(s: String) {
    println!("{}", s);
} // s выходит из области видимости здесь — вызывается Drop, буфер освобождается// s goes out of scope here — Drop runs, the buffer is freed

fn main() {
    let s = String::from("hello");
    takes_ownership(s);   // s перемещается в функцию — владение передано// s is moved into the function — ownership transferred
    // println!("{}", s);  // ОШИБКА: s уже перемещён и недействителен здесь// println!("{}", s);  // ERROR: s was already moved and is invalid here
}

Типы, реализующие маркерный трейт Copy (все примитивы вроде i32, bool, char, а также кортежи/массивы из них) — исключение: присваивание такого значения не move, а обычное побитовое копирование, и старая переменная остаётся полностью валидной. Copy разрешён компилятором только для типов, у которых нет собственного Drop и все поля сами Copy — потому что копирование значения с нетривиальной логикой освобождения ресурса (например, String, владеющего кучей) привело бы к double-free при двух независимых Drop на общий буфер.Types implementing the marker trait Copy (all primitives like i32, bool, char, plus tuples/arrays of them) are the exception: assigning such a value is not a move but an ordinary bitwise copy, and the old variable remains fully valid. The compiler only allows Copy for types with no custom Drop and whose fields are all themselves Copy — because copying a value with nontrivial resource-release logic (e.g. String, which owns heap memory) would cause a double-free from two independent Drop calls on the same buffer.

let x: i32 = 5;
let y = x;              // i32 реализует Copy — это копия, не move// i32 implements Copy — this is a copy, not a move
println!("{} {}", x, y);  // OK: x всё ещё валиден// OK: x is still valid

• The Rust Book — What is Ownership?
• std::ops::Drop — documentation