let x = 42.
Where does it go?

// Where does each piece of data live in memory?
// Print the address of one example from every storage class.

const C_CONST: i32 = 999;            // baked into the binary, read-only
static G_INIT: i32 = 100;            // initialised global → DATA
static mut G_BSS: i32 = 0;           // zero-init global  → BSS
static G_LIT: &str = "hello world";  // bytes in RODATA, slice on stack

fn main() {
    let x: i32 = 42;                 // local primitive → STACK
    let v: Vec<i32> = vec![1, 2, 3]; // header on STACK, buffer on HEAP
    let b: Box<i32> = Box::new(7);   // pointer on STACK, value on HEAP

    println!("CONST  @ {:p}", &C_CONST);
    println!("DATA   @ {:p}", &G_INIT);
    println!("BSS    @ {:p}", unsafe { &raw const G_BSS });
    println!("RODATA @ {:p}  (the bytes \"{}\" live here)", G_LIT.as_ptr(), G_LIT);
    println!("STACK  @ {:p}  (x = {})", &x, x);
    println!("HEAP   @ {:p}  (Vec buffer; header @ {:p})", v.as_ptr(), &v);
    println!("HEAP   @ {:p}  (Box payload; pointer @ {:p})", &*b, &b);
}

// Typical output (addresses vary every run on Linux/macOS due to ASLR):
// CONST  @ 0x55b6e9c1d000   ← low addresses, the binary
// DATA   @ 0x55b6e9c1d100   ← right next to CONST
// BSS    @ 0x55b6e9c1d200
// RODATA @ 0x55b6e9c1d420
// STACK  @ 0x7ffe23a4f8d4   ← high addresses
// HEAP   @ 0x55b6ea102b30   ← middle, allocator-managed

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

const int C_CONST = 999;        // RODATA: read-only, baked into binary
int       g_init  = 100;        // DATA  : initialised global
int       g_bss;                // BSS   : zero-initialised global

int main(void) {
    int   x   = 42;             // STACK : local primitive
    char  arr[5] = "hi!";       // STACK : the string is *copied* here
    char *lit = "hello world";  // pointer on STACK, bytes in RODATA
    int  *p   = malloc(sizeof *p);
    *p = 7;                     // HEAP  : malloc'd value

    printf("RODATA @ %p   (constant)\n", (void*)&C_CONST);
    printf("DATA   @ %p   (g_init=%d)\n", (void*)&g_init, g_init);
    printf("BSS    @ %p   (g_bss=%d, zero by default)\n",
           (void*)&g_bss, g_bss);
    printf("STACK  @ %p   (x=%d)\n",  (void*)&x, x);
    printf("STACK  @ %p   (local arr=\"%s\")\n", (void*)arr, arr);
    printf("RODATA @ %p   (string literal \"%s\")\n", (void*)lit, lit);
    printf("HEAP   @ %p   (*p=%d)\n", (void*)p, *p);

    free(p);
    return 0;
}