Início / coding / Perguntas / 79582363
Accepted
mrn
Asked: 2025-04-19 20:00:08 +0800 CST

Qual é a diferença semântica em Rust entre definir e inicializar uma instância de uma estrutura e uma referência à estrutura?

  • 772

Qual é a diferença semântica entre definir e inicializar uma instância de uma estrutura e uma referência a uma estrutura? Em outras palavras, qual é a diferença entre esses dois programas em Rust?

struct SomeStruct {
    some_field: String,
}

fn main() {
    let s: SomeStruct = SomeStruct { some_field: "string".to_string() };
    println!("{} ", s.some_field);
}

struct SomeStruct {
    some_field: String,
}

fn main() {
    let s: &SomeStruct = &SomeStruct { some_field: "string".to_string() };
    println!("{} ", s.some_field);
}
rust

2 respostas

  1. Best Answer

    no próximo código, sé do tipo SomeStruct, ele possui a struct, ele pode movê-la.

    let s = SomeStruct { some_field: "string".to_string() };

    enquanto no próximo código, sé do tipo &SomeStruct, uma referência imutável a uma struct, a struct está na pilha, ela só não tem um nome e você não pode modificá-la ou movê-la, snão possui a struct.

    let s = &SomeStruct { some_field: "string".to_string() };
// shorthand for 
let unnamed = SomeStruct { some_field: "string".to_string() };
let s = &unnamed;

    A ferrugem tem desreferência automática , então s.some_fieldestá (*s).some_fieldem qualquer coisa "como referência" , e é por isso que essa linha funciona para SomeStructe &SomeStructaté mesmoBox<SomeStruct>

    println!("{} ", s.some_field);

    a principal diferença é que você pode mover SomeStructqualquer um de seus membros, pois você o possui, você não pode fazer isso com uma referência.

    let s = SomeStruct { some_field: "string".to_string() };

let mut s2 = s; // move immutable to mutable
s2.some_field = "string2".to_string(); // modify it
let s3 = s2; // move mutable to immutable
let element = s3.some_field; // move from immutable object, you own it
println!("{} ", element);

// --------------------------------------------------------
let s = &SomeStruct { some_field: "string".to_string() };
let s2 = s.some_field; // error, cannot move out of `s.some_field` which is behind a shared reference
let element = &s.some_field; // can only get immutable reference to members

    você pode modificar um objeto com uma referência mutável, mas não pode movê-lo ou seus membros, e não pode converter uma referência imutável em uma mutável.

    let s = &mut SomeStruct { some_field: "string".to_string() };
s.some_field = "string2".to_string(); // modify a member
let element = s.some_field; // error, cannot move out of `s.some_field` which is behind a mutable reference
    • 3

  2. No primeiro caso, SomeStruct { ... }é um valor do tipo SomeStruct, que está vinculado a s.

    No segundo caso, &SomeStruct { ... }constrói um valor temporário (um valor do tipo SomeStruct) em um local de memória sem nome e recebe uma referência a esse valor temporário. Como a promoção estática de SomeStructnão é possível, a referência tem um tempo de vida limitado . Por exemplo, não é possível retornar sda função, pois o valor por trás da referência é limitado em escopo à função atual, tornando a referência inválida quando a função retorna.

    • 2

relate perguntas