Like for most programming languages, the Rust runtime manages its stored variables, functions, macros and other such pieces of data in two distinct areas of memory: stack memory and heap memory.
Whether a variable is stored in the stack or in the heap depends on its data type, particularly, whether the size of a variable of that data type can be known at compile-time.
Learning this distinction may seem daunting, but understanding it will also further understanding of Rust's ownership system, since memory management is handled with ownership in such a way that most Rust programmers won't need to concern themselves with it, even without a garbage collector.
Stack memory:
Heap memory:
As mentioned on the previous page, C and C++ allow programmers to handle memory manually. More specifically, C allows programmers to manually allocate, reallocate and deallocate spaces on the heap.
Rust, on the other hand, will automatically perform these operations on the heap, depending on the ownership status of a value.
Recall the two string data types mentioned in the last chapter: since String structs are mutable, they are allocated in heap memory, whereas string slices (explained in more detail on the next page) are immutable, and pushed to the stack during execution.
Specifically, String structs are allocated on the heap during their lifetimes, but the actual body of the string is stored on the stack, and the struct has a memory pointer to the first character of the string.
fn main() {
/// The below string struct is built using from(),
/// a built-in method that attempts to convert
/// a variable of one type into another type.
///
/// Here, a string literal (a.k.a. a value of type &str)
/// is pushed onto the stack character by character,
/// and the struct is then allocated in
/// heap memory and has its pointer set to the string literal.
let str_struct = String::from("This is a struct!");
}
When the struct is assigned a new set of characters, these characters are simply pushed onto the stack, and the String struct's pointer is moved to those new characters. The old sequence of characters subsequently goes out of scope, and is eventually popped from the stack.
fn main() {
/// When the below struct is given
/// a new value on the second line,
/// its pointer is moved to the new
/// string literal, and the previous
/// string literal goes out of scope.
let mut str_struct = String::from("This is a struct!");
str_struct = String::from("This is a new string!");
}
However, in the case of one String struct being assigned to another, the one taking the value will have its pointer moved to the same memory as the struct being assigned. This is to save memory, and prevent bloat on the stack.
fn main() {
/// Assigning the first variable
/// to the second will move ownership
/// of the first, making it inaccessible,
/// but will also cause both structs to
/// point to the same sequence of memory
/// cells on the stack.
let str_struct = String::from("This is a struct!");
let second_struct = str_struct;
}
Values stored exclusively on the stack are known by the compiler to never change in storage size during execution, such as integers, booleans and single characters. However, if these need to be stored in a dynamic context for whatever reason, Rust offers a generic (explained later) called Box.
The Box generic allocates heap memory for a given variable, before pushing a pointer to this memory space onto the stack. A variable is said to be boxed if it is being explicitly stored on the heap using this generic, when it would normally be stored on the stack.