Rust 使用带有参数化特征的未声明类型名错误

我试图在参数化类型上实现一些操作（特别是在

Vec

上实现一些常见的“堆栈”操作）。但是，我还不确定这是如何工作的，所以这里是我目前正在努力解决的问题的简化版本：

trait Stack<T> {
    fn top(&self) -> Option<T>;
}

impl Stack for Vec<T> {
    fn top<T>(&self) -> Option<T> {
        match self.len() {
            0 => None,
            n => Some(self[n-1])
        }
    }
}

fn main() {
    let mut stack: Vec<f64> = Vec::new();
    stack.push(1324.4);
    println!("{}", stack.top());
}

trait堆栈{
fn顶部和自身）->选项；
}
用于Vec的impl堆栈{
fn顶部和自身）->选项{
匹配self.len（）{
0=>无，
n=>Some（self[n-1]）
}
}
}
fn main（）{
让mut堆栈：Vec=Vec:：new（）；
堆栈推送（1324.4）；
println！（“{}”，stack.top（））；
}

以上内容无法编译（每夜一次），错误如下：

test.rs:6:20: 6:21 error: use of undeclared type name `T`
test.rs:6 impl Stack for Vec<T> {
                             ^
error: aborting due to previous error

test.rs:6:20:6:21错误：使用未声明的类型名`T`
test.rs:6个用于Vec的impl堆栈{
^
错误：由于上一个错误而中止

这应该可以：

impl<T> Stack<T> for Vec<T> {
    fn top(&self) -> Option<T> {
        match self.len() {
            0 => None,
            n => Some(self[n-1])
        }
    }
}

但此修复反过来表明

top

方法对于该代码的类型不正确。修复错误的一种方法是：

trait Stack<T> {
    fn top(&self) -> Option<&T>;
}

impl<T> Stack<T> for Vec<T> {
    fn top(&self) -> Option<&T> {
        match self.len() {
            0 => None,
            n => Some(&self[n-1])
        }
    }
}

---

如果您想支持返回值而不是引用，这里有两种可能的实现方式。请注意，不能同时使用这两种方式。在大多数情况下，您会看到绑定了

克隆的方式，因为
复制
的任何类型也应该实现
克隆
：

trait Stack<T> {
    fn top(&self) -> Option<T>;
}

// We have values where we duplicate by copying bits naïvely
impl<T> Stack<T> for Vec<T>
    where T: Copy
{
    fn top(&self) -> Option<T> {
        self.last().map(|v| *v)
    }
}

// We have values where we can duplicate them,
// but it might take a function call to do so
impl<T> Stack<T> for Vec<T>
    where T: Clone
{
    fn top(&self) -> Option<T> {
        self.last().map(|v| v.clone())
    }
}

fn main() {
    let stack = vec![1324.4f64];
    println!("{:?}", stack.top());
}

trait堆栈{
fn顶部和自身）->选项；
}
//我们通过天真地复制位来复制值
用于Vec的impl堆栈
其中T:复制
{
fn顶部和自身）->选项{
self.last（）.map（|v |*v）
}
}
//我们有可以复制的价值观，
//但这可能需要函数调用才能实现
用于Vec的impl堆栈
其中T:Clone
{
fn顶部和自身）->选项{
self.last（）.map（| v | v.clone（））
}
}
fn main（）{
让stack=vec！[1324.4f64]；
println！（“{：？}”，stack.top（））；
}
已经有了一个类似.top的方法，名为
.last（），你可以使用。请确保将答案有效，并将答案标记为“接受”，如果它没有答案，请考虑留下注释解释为什么，或编辑你的问题以不同的方式表述问题。请在<代码>顶部>代码>之后删除<代码> <代码>。d不起作用，因为它需要
T:Copy
@sellibitze啊，是的，我在测试中确实删除了它，但当我不知何故将它复制回来时，它逃过了我的眼睛，谢谢！至于
Copy
，我不确定它不起作用的原因，但使用引用修复了它。我对它在浮点和ints。“编译器无法知道
t
类型的值是可复制的-即
t
支持
克隆
特性”-请注意，有能力的类型不同于有能力的类型。更正确的是，是的。我插话给出了一个答案，显示了
复制
或
克隆
边界的用法，如果这是OP想要的。谢谢，我相信OP会像我一样感谢您的输入。
fn main(){
    let mut stack: Vec<f64> = Vec::new();
    stack.push(42.0);
    println!("top: {:?}", stack.top())
}

trait Stack<T> {
    fn top(&self) -> Option<T>;
}

// We have values where we duplicate by copying bits naïvely
impl<T> Stack<T> for Vec<T>
    where T: Copy
{
    fn top(&self) -> Option<T> {
        self.last().map(|v| *v)
    }
}

// We have values where we can duplicate them,
// but it might take a function call to do so
impl<T> Stack<T> for Vec<T>
    where T: Clone
{
    fn top(&self) -> Option<T> {
        self.last().map(|v| v.clone())
    }
}

fn main() {
    let stack = vec![1324.4f64];
    println!("{:?}", stack.top());
}