Início / coding / Perguntas / 78952662
Accepted
Olivier Lasne
Asked: 2024-09-05 18:53:43 +0800 CST

Criando uma função Rust que pode adicionar i64, f64 ou uma mistura de i64 e f64

  • 772

Gostaria de escrever uma addfunção que possa receber como entrada um i64ou f64dois parâmetros.

Consegui chegar ao seguinte:

use std::ops::Add;

fn add<T: Add<Output = T>>(a: T, b: T) -> T{
    a + b
}

fn main() {
    let a: i64 = 10;
    let b: i64 = 20;
    let c: f64 = 10.5;
    let d: f64 = 20.5;

    println!("{:?}", add(a, b)); // Outputs: 30
    println!("{:?}", add(c, d)); // Outputs: 31.0
}

É possível modificar esta função para que seja possível ter:

  • um parâmetro sendo umi64
  • o outro parâmetro é umf64

Se qualquer um dos parâmetros for um, f64fazemos uma conversão e retornamos um f64.

tipo dea tipo deb retornoutype
i64 i64 i64
i64 f64 f64
f64 i64 f64
f64 f64 f64

A função principal teria a seguinte saída:

fn main() {
    let a: i64 = 10;
    let b: i64 = 20;
    let c: f64 = 10.5;
    let d: f64 = 20.5;

    println!("{:?}", add(a, b)); // Outputs: 30    | i64 + i64 -> i64
    println!("{:?}", add(a, c)); // Outputs: 20.5  | i64 + f64 -> f64
    println!("{:?}", add(c, a)); // Outputs: 20.5  | f64 + i64 -> f64
    println!("{:?}", add(c, d)); // Outputs: 30.0  | f64 + f64 -> f64
}
generics

1 respostas

  1. Best Answer

    Você pode fazer isso usando um trait. O trait pode ser idêntico ao trait embutido Add, mas devido à regra órfã você não pode usar o Addtrait em si. Aqui está um exemplo de implementação:

    pub trait MyAdd<RHS> {
    type Output;

    fn add(self, b: RHS) -> Self::Output;
}

impl MyAdd<i64> for i64 {
    type Output = i64;

    fn add(self, b: i64) -> Self::Output {
        self + b
    }
}

impl MyAdd<f64> for f64 {
    type Output = f64;

    fn add(self, b: f64) -> Self::Output {
        self + b
    }
}

impl MyAdd<i64> for f64 {
    type Output = f64;

    fn add(self, b: i64) -> Self::Output {
        self + b as f64
    }
}

impl MyAdd<f64> for i64 {
    type Output = f64;

    fn add(self, b: f64) -> Self::Output {
        self as f64 + b
    }
}

pub fn add<T, U>(a: T, b: U) -> T::Output
where
    T: MyAdd<U>,
{
    a.add(b)
}

    Parque infantil

    A regra órfã impede que você implemente traços estrangeiros em tipos estrangeiros. O código acima contorna isso usando um traço personalizado. Como alternativa, você pode usar tipos personalizados, ou seja, wrappers newtype em torno de i64e f64. Como a implementação corresponde à implementação interna de adição, seria suficiente encapsular um dos dois tipos em um wrapper newtype.

    • 2

relate perguntas