String Basics and Memory Representation in DSA Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a String in Rust?

A String in Rust is a growable, heap-allocated data structure that stores UTF-8 encoded text. It allows modification and dynamic resizing.

intermediate

How does Rust store a String in memory?

Rust stores a String as a pointer to a heap-allocated buffer, along with its length and capacity on the stack. The buffer holds UTF-8 bytes.

beginner

What is the difference between &str and String in Rust?

&str is a string slice, a view into a string, usually immutable and stored on the stack. String is an owned, mutable string stored on the heap.

intermediate

Why does Rust use UTF-8 encoding for strings?

Rust uses UTF-8 because it is efficient in memory, compatible with ASCII, and supports all Unicode characters, making strings flexible and compact.

intermediate

What happens when you push a character to a Rust String that has no remaining capacity?

Rust automatically allocates more heap memory to increase the capacity, copies existing data, then adds the new character. This resizing is transparent to the user.

Which part of a Rust String is stored on the stack?

A Only the pointer

B Pointer, length, and capacity

C The UTF-8 bytes buffer

D Only the length

The String struct stores a pointer to the buffer, length, and capacity on the stack; the actual bytes are on the heap.

What does &str represent in Rust?

A A character array

B An owned, mutable string

C A heap-allocated buffer

D A string slice, a view into a string

&str is a string slice, an immutable view into a string, usually stored on the stack.

Why is UTF-8 encoding used for Rust strings?

A It is compatible with ASCII and supports Unicode

B It uses fixed 4 bytes per character

C It only supports English letters

D It is the fastest encoding for all operations

UTF-8 is compatible with ASCII and supports all Unicode characters, making it flexible and memory efficient.

What happens if you try to modify a &str in Rust?

A It allows modification directly

B It creates a new <code>String</code> automatically

C It causes a compile-time error

D It modifies the original string

&str is immutable; trying to modify it causes a compile-time error.

When a Rust String grows beyond its capacity, what happens?

A It reallocates memory with larger capacity

B It silently truncates the string

C It throws a runtime error

D It converts to <code>&str</code>

Rust reallocates memory with a larger capacity on the heap to accommodate the new data.

Explain how Rust represents a String in memory and why it uses both stack and heap.

Think about what parts are fixed size and what parts can grow.

Describe the difference between String and &str in Rust with examples of when to use each.

Consider ownership and mutability concepts.

Practice

1. What does the String type in Rust represent?

easy

A. A growable, heap-allocated string

B. A fixed-size array of characters

C. A pointer to a string literal

D. An immutable string slice

Solution

1. Step 1: Understand Rust string types

   Rust has two main string types: String and string slices (&str). String is growable and stored on the heap.

2. Step 2: Compare options with definitions

   A growable, heap-allocated string correctly describes String as growable and heap-allocated. Others describe slices or fixed arrays.

3. Final Answer:

   A growable, heap-allocated string -> Option A

4. Quick Check:

   String = growable heap string [OK]

Hint: Remember: String is growable and heap-allocated [OK]

Common Mistakes:

• Confusing String with &str (string slice)
• Thinking String is fixed size
• Assuming String is immutable

2. Which of the following is the correct way to create a new empty String in Rust?

easy

A. let s = String::new();

B. let s = String();

C. let s = new String();

D. let s = String[];

Solution

1. Step 1: Recall Rust String creation syntax

   In Rust, String::new() creates a new empty String.

2. Step 2: Check each option syntax

   let s = String::new(); uses correct Rust syntax. The other options use invalid Rust syntax for creating a String.

3. Final Answer:

   let s = String::new(); -> Option A

4. Quick Check:

   String::new() creates empty String [OK]

Hint: Use String::new() to create empty String [OK]

Common Mistakes:

• Using parentheses like a function call without ::new()
• Trying to use new keyword like other languages
• Using array brackets for String

3. What will be the output of this Rust code?

let s = String::from("hello");
let slice = &s[0..2];
println!("{}", slice);

medium

A. Runtime error

B. hel

C. hello

D. he

Solution

1. Step 1: Understand string slicing in Rust

   The slice &s[0..2] takes characters from index 0 up to but not including 2.

2. Step 2: Extract substring from "hello"

   Characters at index 0 and 1 are 'h' and 'e', so the slice is "he".

3. Final Answer:

   he -> Option D

4. Quick Check:

   Slice 0..2 of "hello" = "he" [OK]

Hint: Slice 0..n means characters from 0 up to n-1 [OK]

Common Mistakes:

• Assuming slice includes index 2
• Expecting full string output
• Thinking slicing causes runtime error

4. Identify the error in this Rust code snippet:

let s = String::from("hello");
let slice = &s[0..4];
println!("{}", slice);
let ch = &s[4];

medium

A. Slice range 0..4 is invalid

B. Cannot index String with single usize

C. Missing semicolon after println!

D. String::from is not valid

Solution

1. Step 1: Check indexing rules for String

   Rust does not allow indexing a String with a single usize like s[4] because strings are UTF-8 encoded and indexing by byte is unsafe.

2. Step 2: Verify other parts

   Slice &s[0..4] is valid. Semicolons and String::from usage are correct.

3. Final Answer:

   Cannot index String with single usize -> Option B

4. Quick Check:

   Single index on String causes error [OK]

Hint: Use slices, not single index, to access String parts [OK]

Common Mistakes:

• Trying to access String by single index
• Confusing slice range validity
• Ignoring Rust UTF-8 string rules

5. Given a UTF-8 encoded Rust String containing emoji and letters, which method safely returns the number of characters (not bytes)?

hard

A. s.len()

B. s.as_bytes().len()

C. s.chars().count()

D. s.bytes().count()

Solution

1. Step 1: Understand difference between bytes and characters

   UTF-8 strings store characters as 1 or more bytes. len() returns byte count, not character count.

2. Step 2: Identify method counting characters

   s.chars().count() iterates over Unicode scalar values (characters) and counts them correctly.

3. Final Answer:

   s.chars().count() -> Option C

4. Quick Check:

   chars().count() counts characters, not bytes [OK]

Hint: Use chars().count() for character count, not len() [OK]

Common Mistakes:

• Using len() which counts bytes, not characters
• Confusing bytes() with chars()
• Assuming as_bytes().len() counts characters