How data types are stored in memory in Rust

Key takeaways:

• Rust uses the stack (static memory) for fixed-size data and the heap (dynamic memory) for dynamically sized data.

• Data types include scalar types (integers, booleans) and compound types (tuples, arrays, vectors).

• Strings comprise &str (immutable, stack-based) and String (mutable, heap-based) types, with metadata on the stack and data on the heap.

  • Shifting string memory using the to_string() method converts &str to String, enabling dynamic resizing and modifications.

Rust is a systems programming language known for its focus on safety and performance. One of the fundamental aspects that contribute to these features is how data types are stored in memory. Understanding this can help developers write efficient Rust programs while minimizing memory-related errors.

Basic data types

Rust provides several built-in data types, each with its own memory representation. Here are some of the basic data types:

How data is stored on the memory level

Different programming languages have different methods for storing data in memory. Let’s make sure we understand the two different types of memories that a programming language’s compiler might use to store data:

• Stack: The stack, also known as static memory, is the most common kind of memory that programming languages use to store basic data structures. This type of memory is suitable for storing static data structures with a fixed size, easily allocated during compilation.

  • Basic working: When a function is called, its stack frame is created, which holds local variables. Once the function exits, the stack frame is popped off the stack, and the memory is automatically reclaimed.

  • Suitable data types to store: Scalar types, tuples, and arrays (when the size is known at compile-time) are usually stored on the stack.

• Heap: This is also known as dynamic memory, and is suitable for storing data structures that grow in size during program execution. Anything with an undetermined size is stored in the heap.

  • Basic working: When we allocate memory on the heap, the memory manager allocates a block of memory at runtime, and a pointer to this memory is stored on the stack. The actual data is stored in the heap, which allows for more flexibility but requires manual management.

  • Suitable data types to store: This is used for dynamically-sized types, such as vectors (Vec<T>) and strings (String).

Let’s explore how Rust strings data type can be stored in memory:

Strings in memory

In Rust, strings can be stored both on the stack and on the heap. This is because there exist two types of strings: one is the static type (&str) which cannot be modified after it has been initialized, and the second is the string literal that is stored on the heap (String).

Here’s how this string is stored in memory.

Let’s take a moment to capture what the illustration above is trying to depict:

• Some metadata about the string is stored on the stack. This metadata is fixed and doesn’t update in size.

• The metadata contains a pointer that references the starting memory location of the string in the heap.

• During the program execution, the heap updates as the string changes, but the stack doesn’t.

Note: Apart from strings, we can have other data structures stored on the heap as well. This can be done by using the Box<T> pointer. This is special type of constructor that allows users to define normal data structures and types on the heap.

Shifting memories for strings

We can convert one type of string to another and shift it from the stack to the heap as well. Shifting memory for Rust strings is particularly useful when we need to convert a static string literal (type &str) into a dynamically sized string (type String) that resides on the heap. This conversion allows for greater flexibility in managing string data, such as modifying its contents or resizing it as needed.

For this purpose, we can use the to_string() method. This method allows us to convert a string literal of type &str into a dynamic string of type String. Here’s a demonstration of the method in use:

We can see above that we created a string of type String from a string literal and even mutated it afterward using the push() method.

Conclusion

The data structures and types in Rust aren’t limited to the ones discussed in this Answer. Rust stores all types very efficiently and effectively by categorizing them into data structures and types that change their size after program compilation and those that stay the same.