主页 / coding / 问题 / 78952662
Accepted
Olivier Lasne
Asked: 2024-09-05 18:53:43 +0800 CST

创建一个可以添加 i64、f64 或 i64 和 f64 混合的 Rust 函数

  • 772

我想编写一个add函数，可以将这两个参数作为i64输入。f64

我得出了以下结论：

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
}

是否可以修改此功能以便可以实现：

  • 一个参数是i64
  • 另一个参数是f64

如果任一参数是，f64我们进行强制转换并返回f64。

类型a 类型b 返回type
i64 i64 i64
i64 f64 f64
f64 i64 f64
f64 f64 f64

主要函数将有以下输出：

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 个回答

  1. Best Answer

    您可以使用特征来实现这一点。该特征可以与内置Add特征相同，但由于孤儿规则，您不能使用该Add特征本身。以下是一个示例实现：

    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)
}

    操场

    孤儿规则阻止您在外部类型上实现外部特征。上面的代码通过使用自定义特征解决了这个问题。或者，您可以使用自定义类型，即围绕i64和的newtype 包装器f64。由于实现与内置的加法实现相匹配，因此将两种类型中的一种包装在 newtype 包装器中就足够了。

    • 2

相关问题