Houses on a
numbered street.

fn main() {
    let arr: [i32; 4] = [10, 20, 30, 40];

    // Rust's [] is bounds-checked. The same machine code as C
    // (load from base + i * 4) plus a runtime "is i < len" check.
    // Out-of-bounds panics; never reads adjacent memory.
    println!("{}", arr[2]);   // 30

    // Same 4-byte stride between consecutive elements.
    for i in 0..4 {
        println!("&arr[{}] = {:p} (val {})", i, &arr[i], arr[i]);
    }

    // Slice the middle two elements. A slice is (ptr, len), and
    // gives you the same fast indexing with the same safety check.
    let mid: &[i32] = &arr[1..3];
    println!("mid = {:?}", mid);   // [20, 30]

    // The line below would panic at runtime:
    //   let bad = arr[5];
    //   error: index out of bounds: the len is 4 but the index is 5
}

#include <stdio.h>

int main(void) {
    int arr[4] = {10, 20, 30, 40};

    // arr[i] is EXACTLY *(arr + i). The C language defines them equal.
    // The compiler turns the index into address arithmetic:
    //   1. multiply i by sizeof(int) = 4
    //   2. add to the base address of arr
    //   3. load 4 bytes from that address
    printf("%d\n", arr[2]);          // 30
    printf("%d\n", *(arr + 2));      // 30  -- same machine code
    printf("%d\n", 2[arr]);          // 30  -- also legal, identical

    // Print each address. They're spaced exactly sizeof(int) apart
    // because the elements live contiguously in memory.
    for (int i = 0; i < 4; i++)
        printf("&arr[%d] = %p (val %d)\n",
               i, (void*)&arr[i], arr[i]);

    return 0;
}

fn main() {
    // Vec<T> is the canonical growable array in Rust. Layout: a
    // (ptr, len, cap) header on the stack, pointing at a heap buffer.
    let mut arr: Vec<i32> = Vec::new();

    // push() is amortized O(1). When the heap buffer is full,
    // Vec doubles its capacity, memcpy's the old data over, and
    // frees the old buffer. The whole machinery is hidden.
    for i in 0..10 {
        arr.push(i * i);
    }

    println!("arr[3] = {}", arr[3]);   // 9
    println!("len = {}, cap = {}", arr.len(), arr.capacity());

    // A slice is the safe pointer for an array region. It's (ptr, len),
    // valid only while the source array is alive.
    let middle: &[i32] = &arr[3..7];
    println!("{:?}", middle);          // [9, 16, 25, 36]
}

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

int main(void) {
    // Heap-allocated array. The size is decided at runtime.
    int n = 10;
    int *arr = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) arr[i] = i * i;

    // Indexing syntax is identical to a stack array. Underneath,
    // arr is just a pointer to the first byte of a contiguous block.
    printf("%d\n", arr[3]);   // 9

    // Grow it. realloc may move the buffer to a bigger free region,
    // copy the old contents over, and free the old one. The pointer
    // can change, so we reassign.
    n = 20;
    arr = realloc(arr, n * sizeof(int));
    for (int i = 10; i < 20; i++) arr[i] = i * i;
    printf("%d\n", arr[15]);  // 225

    free(arr);
    return 0;
}