Introduction

One of the Rust ownership rule states that at any time there can be only one owner of a value. In this exploration, we will see how Rust enforces this rule and how this rule helps with safe and efficient memory management.

Stack-Only Data? Copy

When a variable of a type whose data is stored entirely on the stack is assigned to another variable, Rust simply copies the value of the first variable into the second variable. This is an efficient operation because the size of the value is known at compile time and it is quick to make a copy of the actual value stored on the stack. Variables of all the following types are copied on assignment to another variable of the same type:

All integer types
All floating-point types
Boolean type
Character type, char
Tuples if they only contain types that can be copied

Example

In the following program we assign the value of the variable x to the variable y.

Since x is an integer, this assignment results in copying the value 10, the value of x, to the variable y. If we later change the value of x, it will have no impact on the value of y. Similarly, any change to the value of y will have no effect on the value of x.

Heap Data? Move

Consider a variable of a type for which some or all of its data is stored on the heap. An example of such a type is String. When we assign a variable of such types to another variable, Rust moves the ownership of the value from the first variable to the second variable to enforce the rule that a value can have only one owner at a time. The first variable now becomes uninitialized and the Rust compiler will reject compilation of a program that attempts to access the value of this uninitialized variable.

Example

In the following program we assign the value of the variable s1 to the variable s2.

The variable s1 is of type String with the value "Hello". The assignment statement

let s2 = s1;

moves the ownership of this string to the variable s2. A later statement in the program

println!("s1 is \"{}\"", s1);

tries to print the value of s1. However, since the ownership of the string has moved from s1 to s2, s1 is now uninitialized. The Rust compiler rejects this program with the following error message:

error[E0382]: borrow of moved value: `s1`
  --> main.rs:13:28
   |
3  |   let s1 = String::from("Hello");
   |       -- move occurs because `s1` has type `std::string::String`, which does not implement the `Copy` trait
...
7  |   let s2 = s1;
   |            -- value moved here
...
13 |   println!("s1 is \"{}\"", s1);
   |                            ^^ value borrowed here after move

error: aborting due to previous error

Clone Heap Data On-Demand

However, there can be situations where we want to assign the value of a variable stored on the heap to another variable and still be able to access the value of the original variable. In Rust this requires creating a deep copy of the value of the first variable and then assigning this deep copy to the second variable. Creating a deep copy of a value means that a copy is created of every data object corresponding to the value, whether that data object is stored on the stack or on the heap.

For example, creating a deep copy of a String value will mean creating a copy on the stack of the three values (pointer, length, capacity) that are stored on the stack and a copy on the heap of the buffer that holds the characters in the string.

Calling clone creates a deep copy of a String value

Calling the function clone creates a deep copy of a String value and creates a copy on the stack of the three values (pointer, length and capacity) that are stored on the stack and a copy on the heap of the buffer that holds the characters in the string

Rust types which want to support deep copying implement a method called clone that creates a deep copy of values of that type. Since clone executes the arbitrary code provided by the implementer of the type, execution of this method can be expensive and it is only executed when the programmer explicitly calls it.

Example

In the following program we clone the value of the variable s1 to the variable s2.

The variable s1 is of type String which provides the clone method. The statement

let s2 = s1.clone();

results in the creation of a deep copy of the string value of s1 and assignment of this value to the variable s2. Since s1 has been cloned, and not moved, the value of s1 is still accessible and the following statement is allowed by the Rust compiler

println!("s1 is \"{}\"", s1);

Functions and Ownership

We have discussed the “one owner rule” using examples of assignment statements. The one owner rule is enforced in exactly the same manner when arguments are passed to functions. This means that the type of an argument passed to a function determines whether its value is copied or moved from the variable in the calling function.

Example of Copy

In the following program, the function main has a variable called i with the type integer. main calls a function arg_copy_example and passes i as an argument to arg_copy_example.

Since i is an integer, its value is copied on the stack for the call to arg_copy_example. When the function arg_copy_example returns, the variable i is still accessible in main.

Example of Move

In the following program, the function main has a variable called s with the type String. main calls a function arg_move_example and passes s as an argument to arg_move_example.

Since s is a String, its value is moved to the function arg_copy_example and this variable becomes uninitialized in main. When the function arg_copy_example returns, an attempt to access the value of s in main is rejected by the compiler with the following error message.

error[E0382]: borrow of moved value: `s`
  --> main.rs:13:23
   |
6  |   let s = String::from("Hello");
   |       - move occurs because `s` has type `std::string::String`, which does not implement the `Copy` trait
...
10 |   arg_move_example(s);
   |                    - value moved here
...
13 |   println!("s is {}", s);
   |                       ^ value borrowed here after move

Summary

Rust’s use of copy and move for assigning variables depending on their type ensures that a value has only one owner at any time. Furthermore, the use of move for variables allocated on the heap ensures that values can be assigned quickly such variables. When a value is passed as an argument, Rust again enforces the “one owner rule” and a value that is moved when passed as an argument to another function is no longer owned by the calling function.

Additional Resources

Here are some references to learn more about the topics we discussed in this exploration.

Ownership is discussed in Chapter 4 of The Rust Programming Language by Steve Klabnik and Carol Nichols.