es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

  • es.davy.ai/
  • Programación /
  • ¿Cómo puedo obtener el elemento más grande de una matriz, utilizando genéricos y rasgos?

¿Cómo puedo obtener el elemento más grande de una matriz, utilizando genéricos y rasgos?

24 Jul, 2023 Programación

Recién comencé a aprender Rust y estoy intentando cosas creativamente mientras leo “the Rust Book”.

Sé que es posible crear un método genérico para obtener el elemento más grande de un arreglo, como el siguiente:

fn largest<t: partialord="" +="" copy="">(nums: &[T]) -> T {
    let mut largest = nums[0];
    for &el in nums {
        if el > largest {
            largest = el;
        }
    } 

    return largest;
}

Y llamar a la función main de la siguiente manera:

fn main() {
    let list: Vec<u32> = vec![1,7,4];
    println!("{}", largest(&list)); // 7
}

¿Cómo haría lo mismo pero “extendiendo” el arreglo, como esto?

fn main() {
    let list: Vec<u32> = vec![1,7,4];
    println!("{}", list.largest()); // 7
}

Supongo que la pregunta final es: ¿es posible, sería una mala práctica? ¿Por qué?

“`rust
pub trait Largeble {
fn largest(&self);
}

impl<t: copy="" +="" partialord="" +="" display=""> Largeble for Vec<t> {
fn largest(&self) {

<pre><code> let mut largest = match self.get(0) {
Some(&el) => el,
None => panic!("Se esperaba un arreglo no vacío")
};

for &el in self {
if el > largest {
largest = el;
}
}

println!("{}", largest);
// return largest;
}
</code></pre>

}
“`

Tags:  , , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Para implementar la sintaxis list.largest(), debes extender el tipo Vec<t> al implementar el trait Largeble. Estabas en el camino correcto con tu implementación, pero necesitas definir el tipo de retorno de la función largest() como T (el parámetro de tipo de Vec<t>). Aquí tienes una implementación actualizada:

    pub trait Largeble<t> {
    fn largest(&self) -> T;
}

impl<t: copy="" +="" partialord=""> Largeble<t> for Vec<t> {
    fn largest(&self) -> T {
        let mut largest = match self.get(0) {
            Some(&el) => el,
            None => panic!("Se esperaba un array no vacío")
        };
        for &el in self {
            if el > largest {
                largest = el;
            }
        }
        largest
    }
}

    Con esta implementación, puedes llamar a list.largest() para obtener el elemento más grande:

    fn main() {
    let list: Vec<u32> = vec![1, 7, 4];
    println!("{}", list.largest()); // 7
}

    En cuanto a si es una mala práctica, depende del contexto. Si tienes un caso de uso específico donde necesitas frecuentemente obtener el elemento más grande de un vector, entonces podría ser útil extender el tipo con un método largest(). Sin embargo, si es un caso de uso puntual, podría no valer la pena la complejidad añadida. Además, usar traits para extender tipos puede hacer que el código sea más difícil de entender y mantener, por lo que es importante considerar los compromisos.

Comments are closed.