Generics 什么特征告诉编译器'T'是带有隐式副本的简单类型？

我打算将以下结构与简单的数字类型一起使用，如

i32

，

usize

，但在

contains（）

方法的实现中，Rust迫使我使用

Clone

而不是隐式副本（“无法移出借用的内容”）

我没有发现任何特性可以告诉编译器，

T

是带有隐式副本的简单类型。我能指望编译器放弃数值类型的

clone（）

调用而不影响性能吗

pub struct Rect<T> {
    pub x: T,
    pub y: T,
    pub w: T,
    pub h: T,
}

impl<T> Rect<T> where T: PartialOrd + Add<T, Output=T> + Clone {
    pub fn contains(&self, x: T, y: T) -> bool {
        x >= self.x && y >= self.y
            && x < self.x.clone() + self.w.clone()
            && y < self.y.clone() + self.h.clone()
    }
}

pub struct Rect{
酒吧x:T，
酒吧y:T，
酒吧w:T，
酒吧h:T，
}
impl-Rect其中T:PartialOrd+Add+Clone{
pub fn包含（&self，x:T，y:T）->bool{
x>=self.x&&y>=self.y
&&x

您可以使用trait来指示类型具有复制语义（而不是移动语义）

impl-Rect其中T:PartialOrd+Add+Copy{
pub fn包含（&self，x:T，y:T）->bool{
x>=self.x&&y>=self.y
&&x

我能指望编译器放弃数值类型的

clone（）

调用而不影响性能吗

pub struct Rect<T> {
    pub x: T,
    pub y: T,
    pub w: T,
    pub h: T,
}

impl<T> Rect<T> where T: PartialOrd + Add<T, Output=T> + Clone {
    pub fn contains(&self, x: T, y: T) -> bool {
        x >= self.x && y >= self.y
            && x < self.x.clone() + self.w.clone()
            && y < self.y.clone() + self.h.clone()
    }
}

我们希望编译器能够进行这种优化，但是没有保证（谢谢@DK）

对于

Copy

类型，有一种形式化

clone

语义的方法。RFC从以下内容开始：

一个

Copy

类型的克隆相当于该类型的

memcpy

，这通常是一条不成文的规则

您可以使用trait来指示类型具有复制语义（而不是移动语义）

impl-Rect其中T:PartialOrd+Add+Copy{
pub fn包含（&self，x:T，y:T）->bool{
x>=self.x&&y>=self.y
&&x

我能指望编译器放弃数值类型的

clone（）

调用而不影响性能吗

pub struct Rect<T> {
    pub x: T,
    pub y: T,
    pub w: T,
    pub h: T,
}

impl<T> Rect<T> where T: PartialOrd + Add<T, Output=T> + Clone {
    pub fn contains(&self, x: T, y: T) -> bool {
        x >= self.x && y >= self.y
            && x < self.x.clone() + self.w.clone()
            && y < self.y.clone() + self.h.clone()
    }
}

我们希望编译器能够进行这种优化，但是没有保证（谢谢@DK）

对于

Copy

类型，有一种形式化

clone

语义的方法。RFC从以下内容开始：

一个

Copy

类型的克隆相当于该类型的

memcpy

，这通常是一条不成文的规则

---

好了，你说的克隆不是真的。有一个RFC要求，如果它们都实现了，那么它们具有相同的效果，但是没有任何规定编译器必须用位拷贝替换对

clone

的调用。理想情况下，乐观主义者会注意到这一点，但同样，这也不能保证。好吧，你所说的关于克隆的话是不正确的。有一个RFC要求，如果它们都实现了，那么它们具有相同的效果，但是没有任何规定编译器必须用位拷贝替换对

clone

的调用。理想情况下，乐观主义者会注意到这一点，但同样，这并不能保证。