Rust Vec não inicializado causa erro de Double Free

Acabamos de declarar uma variável não inicializada, mas não estamos usando essa variável

Isso está incorreto. Estamos usando essa variável - ou seja, estamos descartando o Vec, portanto, descartando todos os Vecs nele, e como eles não são inicializados, estamos tentando descartar memória arbitrária.

se esse código realmente aciona comportamento indefinido em ferrugem insegura

Sim, de acordo com a documentação para set_len:

Segurança
<...>
Os elementos em old_len..new_len devem ser inicializados.

Este requisito é explicitamente violado.

comportamento indefinido em ferrugem insegura, que a otimização do compilador pode causar problemas de dupla liberação ou outros

Se você disparar um comportamento indefinido, o processo de compilação pode fazer qualquer coisa com seu programa , por definição. Não é "este código pode estar mal otimizado desta forma" - é "você mentiu para o compilador, todas as apostas estão canceladas".

Isenção de responsabilidade: Cerberus respondeu à pergunta principal. Vou me concentrar nas melhores práticas/perguntas implícitas.

Uso correto deset_len

Subjetivamente, prefiro usar Vec<T>em vez de Vec<MaybeUninit<T>>, especialmente quando posso ter certeza de que os valores desse vetor não inicializado serão preenchidos corretamente mais tarde .

Conforme mencionado na resposta do @Cerberus, set_lensó deve ser usado depois que os elementos forem inicializados.

Ou seja, a maneira correta de usar set_lené:

fn main() {
    const SIZE: usize = 5;

    let mut vec: Vec<Vec<usize>> = Vec::with_capacity(SIZE);

    {
        let spare = vec.spare_capacity_mut();

        (0..SIZE).for_each(|i| { spare[i].write(Vec::new()); });
    }

    //  Safety:
    //  - All elements in 0..SIZE have been initialized.
    unsafe { vec.set_len(SIZE); }
}

Pré-lavagem de suas calças com Rust

Gankra ¹ , um dos principais designers do Rust inseguro nos primeiros dias, escreveu um artigo chamado Pre-pooping your pants with Rust , que é muito apropriado aqui.

A essência do artigo é que uma das principais dificuldades para escrever um código sólido unsafe é prever todas as maneiras pelas quais algo pode dar errado: qualquer retorno antecipado, qualquer pânico, etc., que podem ocorrer antes de você "cumprir" uma promessa.

Dica: é basicamente impossível, tendo em vista que o código está em constante mudança.

A solução que Grankra propôs é, portanto, "pré-cagar" suas calças. Por exemplo, quando você chama vec.drain(start..end), todos os elementos em start..enddevem ser removidos, e apenas os elementos em 0..starte end..(catenados juntos) permanecem. Mas quem sabe o que pode ocorrer ao fazer tudo isso?

Assim, o código para drenagem irá:

1. Defina o comprimento de vecpara start. Ele não o deixará no comprimento atual, nem o definirá no comprimento final.
2. Faça um furo no vec, até que todos os elementos start..endtenham sido retirados.
3. Mova os elementos para dentro end..( start..preenchendo o buraco, parcialmente).
4. E SÓ ENTÃO defina o comprimento de vecpara o número final de elementos que realmente restam.

Se por qualquer razão o Drainiterador vazar no meio de tudo isso, deixando um buraco com elementos não inicializados... está tudo certo , porque todos os elementos 0..startestão (ainda) inicializados, e essa é a única promessa que vecestá sendo feita até (4), e em (4) tudo está bem novamente.

Ou, dito de outra forma: você nunca promete que fará algo que não seja seguro; em vez disso, você primeiro faz e depois anuncia que está feito.

¹ Você pode conhecer Gankra de Learn Rust With Entirely Too Many Linked Lists .

Talvez o Uninit seja inconveniente

Sim. Sim, é.

Na verdade, código escrito corretamente unsafe, com todas as // Safetyanotações, é tedioso de escrever. E verboso. É o que é preciso para escrever unsafecódigo verificável e sólido.

Se você não se importa, então não use unsafe!

Gostaria de ressaltar que não há benefício algum em usar unsafenos cenários que você demonstrou aqui:

fn defaulted_vec<T>(size: usize) -> Vec<T>
where
   T: Default,
{
    (0..size).map(T::default).collect()
}

fn case_1() {
    println!("=== Case 1 ===");
    let vec_a: Vec<Vec<usize>> = vec![vec![0]; 4];
    let _ = vec_a.clone();
    let _: Vec<Vec<usize>> = defaulted_vec(4);
}

fn case_2() {
    println!("=== Case 2 ===");
    let vec_a: Vec<Vec<usize>> = vec![vec![0]; 4];
    {
        let _ = vec_a.clone();
    }
    let _: Vec<Vec<usize>> = defaulted_vec(4);
}

fn main() {
    case_1();
    case_2();
}

defaulted_veccriará Vec4 valores padrão, que são baratos — porque Vec::new()não alocam nada — e você poderá usá-los/substituí-los quando quiser.