let x = 42.
Where does it go?

// Lifetime in code: where each piece of data is born and dies.
fn make_string() -> String {
    let s = String::from("created here");
    s   // ← OWNERSHIP transferred to the caller. The HEAP buffer
        //   survives; the local stack frame's String header is moved.
}       //   No copy; just three pointer-sized fields handed off.

fn main() {
    let outer = make_string();
    println!("{outer}");
}   // ← outer goes out of scope here. Its Drop impl runs:
    //   1) free the HEAP buffer (calls into the allocator)
    //   2) the stack header is dropped automatically.
    //
    // No GC, no manual free. The compiler inserted both steps
    // by reading the lifetime. That's what "ownership" buys you.

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

// Same shape, but C makes you remember to free.
char *make_string(void) {
    char *s = malloc(13);
    memcpy(s, "created here", 13);
    return s;          // pointer is returned; HEAP buffer lives on.
}

int main(void) {
    char *outer = make_string();
    printf("%s\n", outer);
    free(outer);       // ← forget this and you have a leak.
                       //   call it twice and you have a double-free.
                       //   the C compiler will say nothing either way.
    return 0;
}

// Same struct in Rust with explicit layout control.
#[repr(C, packed)]
struct BlockHeader {
    version:     u32,        //  4 bytes - offset 0
    prev_hash:   [u8; 32],   // 32 bytes - offset 4
    merkle_root: [u8; 32],   // 32 bytes - offset 36
    timestamp:   u32,        //  4 bytes - offset 68
    bits:        u32,        //  4 bytes - offset 72
    nonce:       u32,        //  4 bytes - offset 76
}                            // total: 80 bytes

// #[repr(C, packed)]:
//   C      = C-compatible field order and alignment rules
//   packed = no padding bytes between fields
//
// Rust would normally feel free to reorder fields
// for better alignment performance.
// repr(C) stops that.
// packed removes all padding.
// Together they guarantee 80 bytes.

const _: () = assert!(
    std::mem::size_of::<BlockHeader>() == 80,
    "BlockHeader must be exactly 80 bytes"
);

// The compile-time assert catches layout bugs
// before a single block is hashed.
// C's _Static_assert does the same.
// Without it you ship wrong code to production
// and every node rejects your blocks.

/* Bitcoin block header - 80 bytes exactly.
 * Alignment matters: this struct is hashed
 * by passing its raw memory to SHA-256.
 * Any padding would corrupt the hash. */
struct __attribute__((packed)) BlockHeader {
    uint32_t version;         /*  4 bytes - offset 0  */
    uint8_t  prev_hash[32];   /* 32 bytes - offset 4  */
    uint8_t  merkle_root[32]; /* 32 bytes - offset 36 */
    uint32_t timestamp;       /*  4 bytes - offset 68 */
    uint32_t bits;            /*  4 bytes - offset 72 */
    uint32_t nonce;           /*  4 bytes - offset 76 */
};                            /* total: 80 bytes      */

/* __attribute__((packed)) tells the compiler:
 * no padding. ever.
 * sizeof(BlockHeader) must equal exactly 80,
 * because SHA-256 hashes these 80 raw bytes.
 * if the compiler added padding
 * the hash would change.
 * the block would be invalid.
 * every miner would reject it. */

/* verify at compile time: */
_Static_assert(sizeof(struct BlockHeader) == 80,
    "BlockHeader must be exactly 80 bytes");