Rust 中“p: &'a i32” 和“p: &'static i32” 寿命之间的区别？

Question

I started learning Rust a few days back.

This is an extract from the famous book Programming Rust by Jim Blandy.

For the code

fn g<'a>(p: &'a i32) { ... }

let x = 10;
g(&x);

The book says

Rust Choose the smallest possible lifetime for &x, that of the call to g. This meets all constraints: it doesn't outlive x, and encloses the entire call to g. So code must muster.

Q1. What is meant by the smallest possible lifetime for &x ?

For the code

fn f(p: &'static i32) { ... }

let x = 10;
f(&x);

Q2. Why does this code fail? According to my understanding, &'static is used for static global variables which live for the full program. link

Answer 1

A 'static lifetime is a special concept. It specifies that the variable referenced by this needs to exist for the entire lifetime of the program. Using this is a rare case, and requires even rarer precautions to fulfill.

In practice, a &'static reference may only happen in two cases:

• A const declaration
• A static declaration

Both effectively accomplish the same thing, in different ways; the differences aren't important to this question, however. In both cases, the outcome is a variable that is available for the entire lifetime of the program and will not be relocated, thus guaranteeing &'static if borrowed.

Now that we've covered this, let's cover both of your questions.

---

Q1. What is meant by the smallest possible lifetime for &x?

When you define a function as fn g<'a>(p: &'a i32) {... } , you are requiring p to be valid for a lifetime 'a ; this lifetime is determined by the compiler so that 'a is the smallest possible . If the reference is never used outside of the function scope, 'a will be the lifetime of execution of that function, for example. If you use or reference this borrow outside of the function, the lifetime will (evidently) be larger.

The definition of "smallest possible" is simple: the compiler will infer the lifetime based from the time you start that reference, to the last time you use that reference. Dependent borrows also count, and this typically comes back to bite people when dealing with collections.

The reason it is the smallest possible is so that you don't run into crazy situations where you don't have a borrow but it is borrowed anyway; this typically happens when you try to provide your own, incorrect, lifetime hints. There are plenty of cases where it is usually best to let the compiler decide; the other case is struct implementations such as the following:

struct Foo<'a> {
    item: &'a u32
}
impl<'a> Foo<'a> {
    pub fn compare<'b>(&self, other: &'b u32) {
        ...
    }
}

A common fault in situations like this is to describe other to the compiler as 'a , not defining the second 'b lifetime, and thus (accidentally) requiring other to be borrowed for the lifetime of the struct itself.

---

Q2. Why does this code fail? According to my understanding, &'static is used for static global variables which live for the full program.

let x = 10;

This assignment does not have a 'static lifetime. It has an anonymous lifetime defined as less than 'static , because it is not strictly defined as global. The only way to get a 'static borrow on anything is if that source element is defined as const or static .

You can convince yourself of this with this snippet ( playground ):

fn f(p: &'static i32) {
    println!("{}", p)
}

const FOO:i32 = 3;
static BAR:i32 = 4;

fn main() {
    f(&FOO); // Works
    f(&BAR); // Also works
}
f(&x);

Answer 2

A 'static lifetime requirement on a reference requires this argument to be declared for the global lifetime of the program, but x cannot fulfill this condition as it is declared midway through execution.

To be able to use this, declare x as const or static so its lifetime will be 'static and the code will work fine.