Rust 中是否保证了初始化结构字段的顺序？

Question

我在Constructors - The Rustonomicon 中找不到对此的任何引用。是不是保证下面的代码……

struct Mutates {
    n: usize,
}

impl Mutates {
    fn side_effects(&mut self) -> usize {
        self.n += 1;
        self.n
    }
}

#[derive(Debug)]
struct Struct {
    a: usize,
    b: usize,
}

fn main() {
    let mut m = Mutates { n: 0 };

    // note the order of the fields
    dbg!(Struct {
        a: m.side_effects(),
        b: m.side_effects(),
    });
    dbg!(Struct {
        b: m.side_effects(),
        a: m.side_effects(),
    });
}

...总是会打印以下内容？

[src/main.rs:22] Struct{a: m.side_effects(), b: m.side_effects(),} = Struct {
    a: 1,
    b: 2,
}
[src/main.rs:26] Struct{b: m.side_effects(), a: m.side_effects(),} = Struct {
    a: 4,
    b: 3,
}

或者编译器是否可以分配不同的值？

请注意，问题是关于字段初始化而不是声明的顺序。

请注意，此问题专门询问 structs 而不是元组，What is the evaluation order of tuples in Rust? 已回答。

Answer 1

是的，这是有保证的。 Ralf Jung，compiler team contributor 在 Zulip 上确认：

结构体字段的初始化顺序是否有保证？

拉尔夫：

是的 - 它始终是您在初始化程序中写入字段的顺序

结构定义中字段的顺序无关

Answer 2

是的，因为更改它将是一个重大更改：

struct Foo(usize);

impl Foo {
    fn make_val(&mut self) -> usize {
        self.0 + 20
    }
}

struct Bar {
    a: Foo,
    b: usize,
}

let mut foo = Foo(10); // Not copy or clone.
// let bar = Bar {        //Wouldn't work since `foo` is moved into a.
//     a: foo,
//     b: foo.make_val(),
// };

let bar = Bar {
    b: foo.make_val(),
    a: foo,
}

我们还可以观察到，实例化端的字段顺序改变了值在语义上构建的顺序。 Playground.

#![allow(dead_code)]
struct Bar;
impl Bar {
    pub fn new(val: usize) -> Self {
        println!("Making {}", val);
        Bar
    }
}

struct Foo {
    a: Bar,
    b: Bar,
    c: Bar,
}

fn main() {
    Foo {
        a: Bar::new(0),
        c: Bar::new(1),
        b: Bar::new(2),
    };
}

打印出来的

Making 0
Making 1
Making 2

Answer 3

在 lurking 通过 Rust 的问题之后，我遇到了 rust-lang/reference - Document expression evaluation order，它链接到 IRLO thread on Rust expression order of evaluation，其中 user fweimer posts：

关于评估顺序的当前状态是什么？这个很 很想写这个：

struct Item {
    a: u32,
    b: u32,
}

impl Item {
    fn receive_word(&mut self) -> Result<u32, Error> {
        …
    }

    fn receive(&mut self) -> Result<Item, Error> {
        Ok(Item {
            a: self.receive_word()?,
            b: self.receive_word()?,
        })
    }
}

期望是首先收到值a，然后是值 湾。但是对于不确定的评估顺序，必须引入 临时工。

nikomatsakis responds：

该代码是正确的，它不可能改变。事实上，我或多或少认为船已经航行关于改变评估顺序，期间。

还有soon after adds:

更重要的是，在结构字面量中，字段按照您编写它们的顺序进行评估；如果在结构完全构建之前发生恐慌，则中间值会以相反的顺序删除（一旦结构完全构建，字段将按照它们在结构声明中的写入顺序被删除，iirc）。

这增加了我正在寻找的“官方声明”，类似于 Heptamerical 的答案。

Answer 4

Rust 参考文献here 中记录了这一点：

采用多个操作数的表达式按照源代码中的说明从左到右进行计算。

这明确包括结构表达式。文档 PR 是 https://github.com/rust-lang/reference/pull/888，它关闭了 Lonami 的回答中提到的问题 https://github.com/rust-lang/reference/issues/248。