Question

use std::ops::Add;
#[derive(Debug)]
pub struct Vec3<N>{
    x: N,
    y: N,
    z: N
}
impl<N> Vec3<N>{
    pub fn new(x: N, y: N , z: N) -> Vec3<N>{
        Vec3{x:x,y:y,z:z}
    }
}
impl<N : Clone + Add<Output=N>> Vec3<N>{
    pub fn  add(&mut self,v: &Vec3<N>){
        self.x = self.x.clone() + v.x.clone();
        self.y = self.y.clone() + v.y.clone();
        self.z = self.z.clone() + v.z.clone();
    }
}
impl<N: Add<Output=N>> Add for Vec3<N>{
    type Output = Vec3<N>;
    fn add(self, v: Vec3<N>) -> Vec3<N>{
        Vec3{x: self.x + v.x
            ,y: self.y + v.y 
            ,z: self.z + v.z} 
    }
}

这允许我写。

mod vec3;
use vec3::*;
fn main() {
    let mut v1 = Vec3::<f32>::new(1.0,2.0,3.0);
    let v2 = Vec3::<f32>::new(1.0,2.0,3.0);
    v1.add(&v2);
    let v3 = v1 + v2;

    println!("{:?}", v3);
}

此let v3 = v1 + v2;消耗v1和v2。但这可能并不总是需要，所以我添加了另一个带有签名pub fn add(&mut self,v: &Vec3<N>)

的添加函数

我的问题在于此代码段

impl<N : Clone + Add<Output=N>> Vec3<N>{
    pub fn  add(&mut self,v: &Vec3<N>){
        self.x = self.x.clone() + v.x.clone();
        self.y = self.y.clone() + v.y.clone();
        self.z = self.z.clone() + v.z.clone();
    }
}

我需要克隆两个向量的值以避免移动。但我真的很想写这个

self.x = self.x + v.x.clone();或self.x += v.x.clone();我不知道为什么我必须克隆这两个值。

怎么可以这样做？

Answer 1

似乎没有可用的方法来重载＆＃34; + =＆＃34;运营商。但是，你可以避免使用exclipt＆＃34; clone＆＃34;如果用Copy替换Clone trait（但是，如果需要，可以一起使用它们）：

impl<N: Copy + Add<Output = N>> Vec3<N> {
    pub fn add(&mut self, v: &Vec3<N>){
        self.x = self.x + v.x;
        self.y = self.y + v.y;
        self.z = self.z + v.z;
    }
}

注意你不必打电话来克隆＆＃34;克隆＆＃34;一点都没有！

这是Rust的文档中的直接引用：

我的类型何时应该复制？

一般来说，如果你的类型可以实现Copy，它应该。但是有一件重要的事情需要考虑：如果您认为您的类型将来可能无法实现Copy，那么不实施Copy可能是明智的。这是因为删除Copy是一个重大变化：如果我们使Foo非复制，第二个例子将无法编译。

您可以找到有关复制特征here的更多信息。

Answer 2

目前似乎不可能。原因是缺少+ =运算符重载。

但原始类型的clone（）似乎只是一个noop，所以它实际上并不重要，我想。

添加两个数字而不克隆两者

2 个答案:

我的类型何时应该复制？