《Rust Essentials》关于变量栈堆存储位置的描述是否正确？

Great question—this is a really common point of confusion when learning Rust's memory model, and you're absolutely right to question the book's explanation here. Let's break this down clearly:

First: Your Observation Is Correct #

The two addresses printed by println!("{:p} {:p}", &a, &b); (0x23fba4 and 0x23fb90) are both stack addresses. Since stacks grow downward (toward lower memory addresses), the later-declared variable b/game having a smaller address than a/health perfectly aligns with how stacks work. So your initial judgment is spot-on—something's off with the book's explanation.

Where the Book Went Wrong #

The confusion stems from two key mistakes in the text:

• String literals don't live on the heap: In Rust, a string literal like "Space Invaders" is a &'static str—its actual character data is stored in the read-only data segment of your compiled binary, not the heap. Heap allocation only happens for owned strings (String), not string literals.
• &game doesn't get the string's address: When you take &game, you're getting the memory address of the game variable itself (which lives on the stack). The game variable is a small pointer (plus length/capacity for slice types) that points to the string literal's data in the read-only segment—not the data's address directly.

Correct Way to Inspect the Memory #

To see the actual address of the string literal's content, you need to use .as_ptr() on the &str variable. Here's a corrected code example:

fn main() {
    let health = 32;
    let mut game = "Space Invaders";
    
    // Addresses of the stack variables themselves
    println!("Stack address of 'health' variable: {:p}", &health);
    println!("Stack address of 'game' variable: {:p}", &game);
    
    // Address of the string literal's content (read-only segment)
    println!("Address of string literal data: {:p}", game.as_ptr());
}

When you run this, you'll see that the third address is completely different from the first two—this is the location of the actual "Space Invaders" characters, which is nowhere near the stack.

Recap #

• Variables declared with let (like health and game) live on the stack.
• String literals (&'static str) live in the read-only data segment, not the heap.
• &variable gives you the stack address of the variable, not the address of the data it points to.

Your initial intuition about the stack addresses was correct—the book mixed up the variable's stack address with the string data's actual location.

内容的提问来源于stack exchange，提问作者eaniconer