Generics 当泛型参数具有多个数据类型时，如何在rust中实现泛型？

我是生锈的新手

我试图在rust中实现一个通用函数，但我面临着它的问题。我尝试了很多谷歌的例子来获得解决方案，但都没有成功。请帮帮我

在下面的代码中，我想为

点

实现

添加

函数，它可以采用

i32

或另一个

点

fn main() {
    println!("Hello world!");
    let mut point = Point::new(1,1);
    point.add::<i32>(&1);
    point.add::<Point>(&point);
}

#[derive(Copy, Clone)]
struct Point {
    pub x: i32,
    pub y: i32,
}

impl Point {
    pub fn new(x: i32, y: i32) -> Point {
        Point {x, y}
    }

    /**
    Pseudocode as i don't know how to write this in rust
    pub fn add<T: Sized || Point>(&mut self, value: &T) {
            if (T is i32) {
                self.x += = value;
                self.y += value;
            } else (T is Point) {
                self.x += value.x;
                self.y += value.y;
            }
        
    }
    */
}

fn main（）{
println！（“你好，世界！”）；
设mut point=point:：new（1,1）；
点。添加：：（&1）；
点。添加：：（&point）；
}
#[衍生（复制、克隆）]
结构点{
酒吧x:i32，
酒吧y:i32，
}
内点{
新发布（x:i32，y:i32）->点{
点{x，y}
}
/**
伪代码，因为我不知道如何用rust编写
发布fn添加（&mut self，value:&T）{
if（T是i32）{
self.x+==值；
self.y+=值；
}else（T为点）{
self.x+=value.x；
self.y+=value.y；
}
}
*/
}

以下是并排的普通函数和通用函数示例。 结构值{ val:f64， }

struct GenVal{
将军：T，
}
//Val的植入
植入{
fn值（&self）->&f64{
&self.val
}
}
//泛型类型'T的GenVal的impl`
植入基因{
fn值（&self）->&T{
&self.gen_val
}
}
fn main（）{
设x=Val{Val:3.0}；
设y=GenVal{gen_val:3i32}；
println！（“{}，{}”，x.value（），y.value（））；
}

以下是并排的普通函数和通用函数示例。 结构值{ val:f64， }

struct GenVal{
将军：T，
}
//Val的植入
植入{
fn值（&self）->&f64{
&self.val
}
}
//泛型类型'T的GenVal的impl`
植入基因{
fn值（&self）->&T{
&self.gen_val
}
}
fn main（）{
设x=Val{Val:3.0}；
设y=GenVal{gen_val:3i32}；
println！（“{}，{}”，x.value（），y.value（））；
}

您可以使用特征来实现这一点。由于

点

是

复制

，因此也不需要使用引用：

#[derive(Copy, Clone)]
struct Point {
    pub x: i32,
    pub y: i32,
}

impl Point {
    fn new(x: i32, y: i32) -> Point {
        Point { x, y }
    }
}

trait AddToPoint<T> {
    fn add(&mut self, value: T);
}

impl AddToPoint<i32> for Point {
    fn add(&mut self, value: i32) {
        self.x += value;
        self.y += value;
    }
}

impl AddToPoint<Point> for Point {
    fn add(&mut self, value: Point) {
        self.x += value.x;
        self.y += value.y;
    }
}

fn main() {
    println!("Hello world!");
    let mut point = Point::new(1,1);
    point.add(1);
    point.add(point);
}

---

你可以利用一个特质来做到这一点。由于

点

是

复制

，因此也不需要使用引用：

#[derive(Copy, Clone)]
struct Point {
    pub x: i32,
    pub y: i32,
}

impl Point {
    fn new(x: i32, y: i32) -> Point {
        Point { x, y }
    }
}

trait AddToPoint<T> {
    fn add(&mut self, value: T);
}

impl AddToPoint<i32> for Point {
    fn add(&mut self, value: i32) {
        self.x += value;
        self.y += value;
    }
}

impl AddToPoint<Point> for Point {
    fn add(&mut self, value: Point) {
        self.x += value.x;
        self.y += value.y;
    }
}

fn main() {
    println!("Hello world!");
    let mut point = Point::new(1,1);
    point.add(1);
    point.add(point);
}

---

您是否考虑过实施替代方案？这是否回答了您的问题@IInspectable是的，我尝试过，但是在为

i32

实现

中的
后，调用
点时出错。添加：（&point）
@E_net4是有针对性的，您建议的链接是为
i32
和
f32
实施
go
方法，但这里我只想为
点实施。您考虑过改为实施吗？这是否回答了您的问题@IInspectable是的，我尝试过，但是在为
i32
实现
中的
后，调用
点时出错。添加：（&point）
@E_net4是有针对性的，你建议的链接是为
i32
和
f32
实现
go
方法，但这里我只想为
点
实现。问题是要求函数重载的道德等价物，例如，一个函数
add
，可以用
i32
或另一个
点调用。问题是函数重载的道德等价物，即一个函数
add
，可以用
i32
或另一个
点调用。
use std::ops::AddAssign;

#[derive(Copy, Clone)]
struct Point {
    pub x: i32,
    pub y: i32,
}

impl Point {
    fn new(x: i32, y: i32) -> Point {
        Point { x, y }
    }
}

impl AddAssign<i32> for Point {
    fn add_assign(&mut self, value: i32) {
        self.x += value;
        self.y += value;
    }
}

impl AddAssign<Point> for Point {
    fn add_assign(&mut self, value: Point) {
        self.x += value.x;
        self.y += value.y;
    }
}

fn main() {
    println!("Hello world!");
    let mut point = Point::new(1,1);
    point += 1;
    point += point;
}