Why does the Rust compiler allow index out of boun

问题:

Can someone explain why this compiles:

fn main() {
    let a = vec![1, 2, 3];
    println!("{:?}", a[4]);
}

When running it, I got:

thread '' panicked at 'index out of bounds: the len is 3 but the index is 4', ../src/libcollections/vec.rs:1132

回答1:

In order to understand the issue, you have to think about it in terms of what the compiler sees.

Typically, a compiler never reasons about the value of an expression, only about its type. Thus:

• a is of type Vec<i32>
• 4 is of an unknown integral type
• Vec<i32> implements subscripting, so a[4] type checks

Having a compiler reasoning about values is not unknown, and there are various ways to get it.

• you can allow evaluation of some expression at compile-time (C++ constexpr for example)
• you can encode value into types (C++ non-type template parameters, using Peano's numbers)
• you can use dependent typing which bridges the gap between types and values

Rust does not support any of these at this point in time, and while there has been interest for the former two it will certainly not be done before 1.0.

Thus, the values are checked at runtime, and the implementation of Vec correctly bails out (here failing).

回答2:

If you would like to access elements of the Vec with index checking, you can use the Vec as a slice and then use its get method. For example, consider the following code.

fn main() {
    let a = vec![1, 2, 3];
    println!("{:?}", a.get(2));
    println!("{:?}", a.get(4));
}

This outputs:

Some(3)
None

回答3:

Maybe what you mean is :

fn main() {
    let a = vec![1, 2, 3];
    println!("{:?}", a[4]);
}

This returns an Option so it will return Some or None. Compare this to:

fn main() {
    let a = vec![1, 2, 3];
    println!("{:?}", &a[4]);
}

This accesses by reference so it directly accesses the address and causes the panic in your program.