Когда происходит временное разрушение?

До сих пор я предполагал, что в конце оценки заявления, породившего его, было уничтожено временное место.

Однако, похоже, что существует исключение при использовании временного для инициализации поля struct.

PeterHall предоставил простой пример кода, иллюстрирующий разницу в комментарии к его ответ, который я упростил :

struct Wrapper<'a> {
    cmd: &'a Cmd<'a>,
}

struct Cmd<'a> {
    args: &'a Option<String>,
}

impl <'a> Cmd<'a> {
    fn new(args: &'a Option<String>) -> Cmd<'a> {
        Cmd {
            args: args,
        }
    }
}

pub fn main() {
    // OK
    let cmd = Cmd {
        args: &None,
    };

    // OK
    let cmd = Wrapper {
        cmd: &Cmd {
            args: &None,
        }
    };

    // Lifetime error
    let cmd = Some(Cmd {
        args: &None,
    });

    // Lifetime error
    let cmd = Cmd::new(&None);
}

Итак, что такое точное правило для временного разрушения?

Ответ 1

Сначала посмотрим на вторую строку с ошибкой:

let cmd = Cmd::new(&None);

&None создает временное время жизни одной строки. Cmd::new возвращает a Cmd, который имеет одинаковое время жизни. Затем мы пытаемся сохранить это временное значение в переменной с помощью let.

Опорные состояния ржавчины:

Когда создается временное rvalue, которое назначается в let декларация, однако, временная создается со временем жизни вместо этого заключенный блок...

Он пытается увеличить время жизни Cmd временное, но это зависит от времени жизни временного элемента &None, и поскольку это временное значение фактически не хранится в let (исключение из правила о временные данные, продолжающиеся до конца инструкции), его время жизни меньше времени жизни Cmd, и вы получаете пожизненную ошибку.

Операторы прямой структуры работают, потому что время жизни let относится к структуре и ее членам.

Тот факт, что он не работает для Some (enum), кажется мне ошибкой (или, по крайней мере, отсутствующей функцией).