Início / coding / Perguntas / 78130891
Accepted
philip
Asked: 2024-03-09 08:49:12 +0800 CST

Como a classificação de um vetor de referências a referências de str funciona nas strings e não nas referências mais externas?

  • 772

Enquanto aprendia rust, encontrei este trecho incorporado em uma resposta a um problema online. Eu não esperava que essa fosse a resposta correta, pois ingenuamente pensei que elem_refs.sort()classificaria pelas referências no vetor em vez das strings.

Por que elem_refs.sort() classifica as strings em vez das referências às strings (ou melhor, &str's)? Obviamente, é conveniente e o resultado desejado, mas onde esse comportamento está documentado? Muito obrigado por seus insights.

fn main() {
    let list = ["b", "d" , "q", "a", "t" ];
    let mut elem_refs: Vec<&&str> = list.iter().collect();
    println!("{:?}", elem_refs);
    elem_refs.sort();
    println!("{:?}", elem_refs);
}

["b", "d", "q", "a", "t"]

["a", "b", "d", "q", "t"]

sorting

2 respostas

  1. Primeiro, sortrequer o trait Ord. Ordé implementado para referências aqui , o que desreferencia os argumentos e chama Ord::cmpnovamente:

    impl<A: ?Sized> Ord for &A
where
    A: Ord,
{
    #[inline]
    fn cmp(&self, other: &Self) -> Ordering {
        Ord::cmp(*self, *other)
    }
}

    Quando você chama sort, o compilador procura uma implementação de Ordfor &&str. Ele encontra o genérico acima, atribui &stra Ae, de acordo com o limite A: Ord, procura uma implementação de Ordfor &str. Ele encontra o mesmo novamente, atribui stra Ae procura uma implementação de Ordfor str. Ele encontra a implementação específica para str here , o que encerra a pesquisa. Esta cadeia de implementações é usada para gerar sua sortfunção específica.

    • 3
  2. Best Answer

    No meu entender, existem duas respostas para esta questão: a “filosófica” e a prática.

    A resposta "filosófica" é que Rust prefere lidar com dados, e não com ponteiros. Mesmo que você tenha uma referência a um valor, muitas vezes ela é tratada apenas como um identificador para o valor, e o fato de que nos bastidores uma referência é apenas um ponteiro, com um endereço específico na memória, é um detalhe que Rust prefere que você não pense demais. (Pelo menos, este é o meu entendimento da filosofia Rust. Sinta-se à vontade para me corrigir)
    Mesmo se você tiver duas referências, compará-las usando ==as compararia por valor (devido a uma chamada para PartialEq::eq). Se você realmente deseja compará-los por referência, primeiro será necessário convertê-los em ponteiros ou chamar uma função como std::ptr::addr_eq. (E, no meu entender, até mesmo a ideia de comparação por referência é considerada não-idiomática em Rust)

    Agora, a resposta prática é que a implementação de sortusa a Ordcaracterística para decidir a ordem dos elementos na fatia classificada. ( veja a wherecláusula na assinatura desort )
    A Ordcaracterística (e a PartialOrdcaracterística relacionada) existe com o propósito de decidir a ordem dos tipos por valor e, de fato, a implementação de Ordchamadasstr for self.as_bytes().cmp(other.as_bytes())para comparar os bytes reais contidos nas strings.

    Um pouco relacionado a isso está o comportamento do operador ponto ( .) no Rust, que é usado para acessar os campos e métodos de um tipo. Usar o operador ponto em uma variável sempre desreferencia implicitamente essa variável se for uma referência, antes de realmente acessar o campo/método.
    Ele irá até desreferenciar várias vezes se for uma referência aninhada. Isso significa que para qualquer tipo T(mesmo tipos primitivos como i32), se você tiver uma variável let my_var: &&&T = ...e fizer algo como my_var.some_field, isso seria equivalente a (***my_var).some_field.
    Isso, por sua vez, significa que qualquer método chamado em uma referência (como os métodos Ordchamados pela implementação de sort), lidará com os dados reais dentro da referência, e não com a referência em si.

    Uma isenção de responsabilidade que gostaria de acrescentar é que sou um pouco novo no Rust e, portanto, nem tudo o que disse pode estar 100% correto. Estou aberto a comentários sobre esta resposta me corrigindo, para que eu possa editar esta resposta com as correções.

    • 1

relate perguntas