Skip to main content
Rust offers two primary ways to handle text data: string literals and the String type. Understanding the differences between these two is crucial for effectively managing ownership and memory in your Rust applications.

​
String Literals

String literals in Rust are immutable by default and are embedded directly into your program’s binary within a read-only memory section. Although you can declare a string literal variable as mutable using the mut keyword, you cannot change the individual characters of the literal. Instead, you can only reassign the variable to reference a different literal. For instance, consider the following code snippet: 
fn main() {
    // String literal
    let mut s = "hello";
    println!("{}", s);

    s = "world";
    println!("{}", s);
}
In this example, the variable s is declared as mutable, allowing you to change its reference. Initially, the program prints “hello”, and after being reassigned, it prints “world”. Remember, even though s is mutable, the content of each string literal remains immutable.
Always keep in mind that string literals are hardcoded into your program’s binary and cannot be altered at runtime.

​
The String Object

In contrast to string literals, the String type in Rust represents a heap-allocated, growable string. This means that String objects can be modified in place—including their size—during runtime, providing much greater flexibility compared to string literals. The following example demonstrates how to initialize a String object and modify it using the push_str method: 
fn main() {
    // String object
    let mut sobj = String::from("hello");
    println!("{}", sobj);

    sobj.push_str(", world!");
    println!("{}", sobj);
}
Here, the variable sobj holds a heap-allocated string initialized with “hello”. The push_str method appends ”, world!” to the existing string, so when printed, it outputs “hello, world!”.

​
Combined Example: String Literals vs. String Objects

Below is a comprehensive example that illustrates the use of both string literals and String objects in a single program: 
fn main() {
    // String literal example
    let mut s = "hello";
    println!("{}", s);

    s = "world";
    println!("{}", s);

    // String object example
    let mut sobj = String::from("hello");
    println!("{}", sobj);

    sobj.push_str(", world!");
    println!("{}", sobj);
}
When you run this program, the output will be: 
hello
world
hello
hello, world!
This example clearly shows that:
  • String Literals are immutable and stored in read-only memory.
  • String Objects are mutable and allocated on the heap, making them ideal for scenarios where you need to modify or extend the string value.
Understanding the differences between string literals and String objects is essential for writing efficient and safe Rust code. This knowledge helps you choose the appropriate type based on whether immutability or dynamic modification is required.
For further reading, consider exploring the Rust Programming Language Book to deepen your understanding of memory management and ownership in Rust.

Watch Video