Question

尝试编译以下代码：

#[derive(Show)]
pub enum E1 {
    A,
    B,
}
#[derive(Show)]
pub enum E2 {
    X(E1),
    Y(i32),
}

impl std::fmt::String for E1 {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Show::fmt(self, f)
    }
}

impl std::fmt::String for E2 {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Show::fmt(self, f)
    }
}

impl std::error::Error for E2 {
    fn description(&self) -> &'static str {
        match *self {
            E2::X(x) => {
                let d: &'static str = x.description();
                d
            },
            E2::Y(_) => "Unknown error",
        }
    }
}

impl std::error::Error for E1 {
    fn description(&self) -> &'static str {
        match *self {
            E1::A => "Error A",
            E1::B => "Error B",
        }
    }
}

fn main() { }

产生错误：

a.rs:17:39: 17:40 error: `x` does not live long enough
a.rs:17                 let d: &'static str = x.description();
                                              ^
note: reference must be valid for the static lifetime...
a.rs:15:9: 21:10 note: ...but borrowed value is only valid for the match at 15:8
a.rs:15         match *self {
a.rs:16             E2::X(x) => {
a.rs:17                 let d: &'static str = x.description();
a.rs:18                 d
a.rs:19             },
a.rs:20             E2::Y(_) => "Unknown error"
        ...
a.rs:15:15: 15:20 error: cannot move out of borrowed content
a.rs:15         match *self {
                      ^~~~~
a.rs:16:19: 16:20 note: attempting to move value to here
a.rs:16             E2::X(x) => {
                          ^
a.rs:16:19: 16:20 help: to prevent the move, use `ref x` or `ref mut x` to capture value by reference
a.rs:16             E2::X(x) => {
                          ^
error: aborting due to 2 previous errors

将匹配模式更改为E2::X(ref x)会产生更详细的错误，但让我感到困惑：

a.rs:16:19: 16:24 error: cannot infer an appropriate lifetime for pattern due to conflicting requirements
a.rs:16             E2::X(ref x) => {
                          ^~~~~
a.rs:17:39: 17:40 note: first, the lifetime cannot outlive the expression at 17:38...
a.rs:17                 let d: &'static str = x.description();
                                              ^
a.rs:17:39: 17:40 note: ...so that pointer is not dereferenced outside its lifetime
a.rs:17                 let d: &'static str = x.description();
                                              ^
a.rs:15:9: 21:10 note: but, the lifetime must be valid for the match at 15:8...
a.rs:15         match *self {
a.rs:16             E2::X(ref x) => {
a.rs:17                 let d: &'static str = x.description();
a.rs:18                 d
a.rs:19             },
a.rs:20             E2::Y(_) => "Unknown error"
        ...
a.rs:16:19: 16:24 note: ...so that variable is valid at time of its declaration
a.rs:16             E2::X(ref x) => {
                          ^~~~~
error: aborting due to previous error

我看到它的方式，x只需要活到x.description()返回，但编译器似乎需要比整个匹配块更长久。为什么？为什么它还坚持在复制时将x视为参考可能更合乎逻辑？

Answer 1

至于x与ref x，x将无效，因为您只有self的引用，因此无法移出E1值你所能做的只是参考它。

但是现在更重要的是：你的description方法的定义不正确，Rust编译器并没有警告你那个而是让生活变得不愉快对你而言。

这是description方法的实际定义：

fn description(&self) -> &str;

请注意：&str，而不是&'static str。编译器应该反对签名中的'static，但唉，它没有。（这是https://github.com/rust-lang/rust/issues/21508的主题，由于这个问题而提交。）通常指定一个更长的生命周期就好了，因为它只会缩小到大小，但在某些情况下它不会做您认为它会特别改变E1的{{1}}方法，以返回description生命周期，但在&str定义中仍然想要返回E2 。当然，&'static str引用不是x，因此无法执行此操作。令人困惑，对吧？别担心，这主要不是你的错！

要解决此问题，请删除所有出现的'static，以匹配特征定义。然后因为'static位于x内，所以生命周期将恰当排列。

匹配模式中变量的生命周期

1 个答案: