Início / coding / Perguntas / 79128713
Accepted
whatf0xx
Asked: 2024-10-26 22:15:28 +0800 CST

Preciso alocar com `Box` ou similar para que diferentes tipos que compartilham uma característica sejam aceitos pelo compilador?

  • 772

Eu estava analisando esta questão em relação à resposta a um problema simples que tenho: quero ter um bloco if/else para decidir se uma iteração deve ter uma barra de progresso tqdm acompanhante :

fn run(n: usize, verbose: bool) {
  let it = if verbose { tqdm(0..n) } else { 0..n };
  for _ in it { _ }
}

O código acima não compila, porque os dois braços do if/else têm tipos diferentes, um é a Rangee o outro é a Tqdm<Range>. No entanto, com base na pergunta vinculada no topo, fiz a seguinte modificação e ele compila bem:

fn run(n: usize, verbose: bool) {
  let it: Box<dyn impl Iterator<Item = usize>> = if verbose { 
    Box::new(tqdm(0..n))
  } else {
    Box::new(0..n)
  };
  for _ in it { _ }
}

Ao especificar o tipo (na verdade, isso é necessário, apenas envolvê-lo Boxnão ajuda), posso fazer o código compilar. No entanto, ingenuamente sinto que isso significa que há uma alocação extra de heap do dyn Iteratorobjeto, enquanto antes tudo (pelo menos como eu entendo) era mais ou menos manipulado dentro do quadro de pilha. Sei que, em geral, o despacho dinâmico (que eu acho que é, mas não tenho certeza absoluta) vem com um impacto no desempenho.

Antes de embrulhar, Boxtentei apenas anotar, dyn Iterator<Item = usize>mas não funcionou. Acho que porque, de alguma forma, a Boxabstração é necessária, mas não entendi bem o porquê.

Existe uma maneira de fazer esse código, ou a ideia por trás dele, compilar sem o Boxe a alocação de heap? Isso é menos importante do que eu penso? Se isso é impossível, por que não posso fazer o simples dyn Iteratorsem o Boxcomo mencionei acima?

rust

1 respostas

  1. Best Answer

    Você está correto, isso Box<_>resultaria em uma alocação e isso dynresultaria em despacho dinâmico.

    Uma alternativa sem alocação para Box<dyn _>is &dyn _(como sua dynideia simples, mas com a sintaxe correta), mas que precisa ser emprestada de um local que permaneça no escopo (fora dos blocos ifou else):

    fn run(n: usize, verbose: bool) {
  let mut progress;
  let mut regular;
  let it: &mut dyn Iterator<Item = usize> = if verbose {
      progress = tqdm(0..n);
      &mut progress
  } else {
      regular = 0..n;
      &mut regular
  };
  for _ in it { }
}

    Se você precisasse retornar o iterador, a abordagem acima não funcionaria, pois você não pode retornar referências a variáveis ​​locais. Em vez disso, você poderia usar a seguinte construção, que também evita dyn:

    fn run_later(n: usize, verbose: bool) -> impl Iterator<Item = usize> + 'static {
  let mut progress = None;
  let mut regular = None;
  
  if verbose {
      progress = Some(tqdm(0..n));
  } else {
      regular = Some(0..n)
  }
  
  progress.into_iter().flatten().chain(regular.into_iter().flatten())
}
    • 4

relate perguntas