Início / coding / Perguntas / 79428297
Accepted
kesarling
Asked: 2025-02-11 05:00:42 +0800 CST

Como posso garantir ao compilador Rust que uma determinada variável será inicializada em um loop for?

  • 772

Esta questão está relacionada à pergunta feita aqui: Como declarar uma variável, mas não atribuí-la?

Meu problema é um pouco diferente. MRE:

let var: MyGenericType;
for value in vec_of_values_of_my_generic_type {
    // one of the values is mathematically guaranteed to meet this condition because the vector is special
    if <value meets a certain condition> {
        var = value;
    }
}

<use var>

Erro:

error[E0381]: used binding `var` is possibly-uninitialized
   --> example/src/lib.rs:127:23
    |
120 |             let var: MyGenericType;
    |                 -- binding declared here but left uninitialized
...
123 |                     var = value;
    |                     -- binding initialized here in some conditions
...
127 |             foo(var);
    |                       ^^ `var` used here but it is possibly-uninitialized

Como posso corrigir isso?

rust

3 respostas

  1. Best Answer

    Use a ferramenta certa para o trabalho, aqui seria Iterator::find, em vez de fazer um loop manualmente:

    let var = vec_of_values_of_my_generic_type
    .into_iter()
    .find(|value| <value meets a certain condition>)
    .unwrap();
    • 1

  2. Se a estrutura do seu código significa que o compilador não pode ter certeza de que seu valor foi inicializado, use Option:

    let mut var: Option<MyGenericType> = None;

for value in vec_of_values_of_my_generic_type {
    if <value meets a certain condition> {
        var = Some(value);
    }
}

let var = var.expect("my generic type not set");

    O expect()extrai o valor do Optione entra em pânico com essa mensagem se ele nunca foi definido.

    • 0

  3. A resposta para sua pergunta literal sobre como você pode fornecer ao compilador uma certa garantia que ele não pode provar por si só - é para isso que unsafe {}serve. Ele está literalmente dizendo ao compilador "Aqui está um código sobre o qual você não tem informações suficientes para dizer se é seguro ou não. Mas eu tenho essas informações e posso garantir que ele é realmente seguro!". Aqui, você pode usar um MaybeUninitwrapper de tipo especial para emular o comportamento que você está pedindo:

    use std::mem::MaybeUninit;

struct MyGenericType;


fn foo(v: MyGenericType) { unimplemented!() }
fn get_vec() -> Vec<MyGenericType> { unimplemented!() }
fn condition(v: &MyGenericType) -> bool { unimplemented!() }



fn main() {
    let vec_of_values_of_my_generic_type = get_vec();
    
    let mut var: MaybeUninit<MyGenericType> = MaybeUninit::uninit();
    for value in vec_of_values_of_my_generic_type {
        
        if condition(&value) {
            var.write(value);
        }
    }

    unsafe{ foo(var.assume_init()) };
}

    Aqui, você está literalmente dizendo ao compilador: "Suponha que a variável esteja inicializada". E como MaybeUninit::assume_init()é uma unsafefunção, você não tem escolha a não ser envolvê-la no unsafe {}bloco para dizer ao compilador que você está fornecendo as garantias.

    (Você pode fazer algo parecido com o unsafe Option::unwrap_unchecked, se em vez disso você encapsular o valor em Option).

    Link para o playground

    • 0

relate perguntas