Open Menu

    String and &str in Rust

    Flavio Del Grosso

    Flavio Del GrossoJan 18, 2024

    4 min read913 words

    Rust, known for its emphasis on memory safety without sacrificing performance, has two main string types: String and &str. These types serve different purposes and understanding their differences is very important for writing efficient and safe Rust code.

    String

    The String type represents an owned, growable, and mutable UTF-8 encoded string. In other words, a String is a heap-allocated string, and you have full control over its contents.

    Here's an example demonstrating the creation and manipulation of a String:

    rust

    fn main() {
        // Creating an empty String
        let mut my_string = String::new();
     
        // Appending a string slice to the String
        my_string.push_str("Hello, ");
     
        // Appending another String
        let other_string = String::from("world!");
        my_string.push_str(&other_string);
     
        // Printing the result
        println!("{}", my_string);  // Output: Hello, world!
    }

    In this example, String::new() creates an empty String, and push_str is used to append string slices or other String instances.

    &str

    On the other hand, &str is a string slice that is a view into a string. It's a reference to some UTF-8 encoded data, usually a portion of a String or a string literal.

    Let's explore the usage of &str:

    rust

    fn print_greeting(greeting: &str) {
        println!("{}", greeting);
    }
     
    fn main() {
        // Using a string literal
        let hello = "Hello, world!";
        print_greeting(&hello);
     
        // Using a portion of a String
        let my_string = String::from("Hola, mundo!");
        let hola: &str = &my_string[0..4];
        print_greeting(hola);
    }

    In this example, print_greeting is a function that takes a &str as an argument. You can pass both string literals and slices of String instances to this function.

    Key Differences

    1. Ownership and Mutability:

      • String owns its data and is mutable.
      • &str is an immutable reference to a slice of data owned by another variable.
    2. Allocation:

      • String allocates memory on the heap to store its data.
      • &str does not own the data; it is a reference to existing data.
    3. Usage:

      • Use String when you need ownership and dynamic string manipulation.
      • Use &str when you want to reference existing data or pass slices without taking ownership.

    Conclusion

    Understanding the distinction between String and &str is crucial for writing efficient, safe, and expressive Rust code. Whether you're dealing with owned, mutable strings or referencing existing data, Rust's type system ensures memory safety without sacrificing performance.


    Share on