Rust 错误类型不匹配：应为'；集合：：vec：：vec<；i32>'；，发现'&；集合：：vec：：vec<；i32>'；

我试图使用

选择\u排序

创建排序向量，同时保留原始未排序向量：

fn main() {
    let vector_1: Vec<i32> = vec![15, 23, 4, 2, 78, 0];
    let sorted_vector = selection_sort(&vector_1);
    println!("{:?} is unsorted, \n{:?} is sorted.", &vector_1, &sorted_vector);
}

fn selection_sort(vector_1: &Vec<i32>) -> Vec<i32> {
    let mut vector = vector_1;
    let start = 0;
    while start != vector.len() {
        for index in (start .. vector.len()) {
            match vector[index] < vector[start] {
                true  => vector.swap(index, start),
                false => println!("false"), // do nothing
            }
        }
        start += 1;
    }
    vector
}

fn main（）{
设vector_1:Vec=Vec！[15,23,4,2,78,0]；
让排序的向量=选择排序（&vector_1）；
println！（“{：？}未排序，\n{：？}已排序。”，&vector_1，&sorted_vector）；
}
fn选择\排序（向量\ 1:&Vec）->Vec{
设mut vector=vector_1；
让start=0；
while start！=vector.len（）{
对于中的索引（start..vector.len（））{
匹配向量[索引]<向量[开始]{
true=>vector.swap（索引，开始），
false=>println！（“false”），//什么也不做
}
}
开始+=1；
}
矢量
}

错误：

   Compiling selection_sort v0.1.0 (file:///home/ranj/Desktop/Rust/algorithms/sorting/selection_sort)
src/main.rs:21:5: 21:11 error: mismatched types:
 expected `collections::vec::Vec<i32>`,
    found `&collections::vec::Vec<i32>`
(expected struct `collections::vec::Vec`,
found &-ptr) [E0308]
src/main.rs:21     vector
                   ^~~~~~
src/main.rs:21:5: 21:11 help: run `rustc --explain E0308` to see a detailed explanation
error: aborting due to previous error
Could not compile `selection_sort`.

编译选择\u排序v0.1.0(file:///home/ranj/Desktop/Rust/algorithms/sorting/selection_sort)
src/main.rs:21:5:21:11错误：不匹配的类型：
应为“collections:：vec:：vec`，
找到`&集合：：vec：：vec`
（应为结构`collections:：vec:：vec`，
找到和-ptr）[E0308]
src/main.rs:21矢量
^~~~~~
src/main.rs:21:5:21:11帮助：运行'rustc--explain E0308'查看详细说明
错误：由于上一个错误而中止
无法编译“选择\排序”。

您的问题可以简化为以下内容（请查看并遵循如何在此处提问时创建一个：

T

和

&T

是不同的类型

最终，您的代码现在没有意义。要将

&Vec

转换为

Vec

，您需要克隆它：

fn selection_sort(vector: &Vec<i32>) -> Vec<i32> {
    let mut vector = vector.clone();
    let mut start = 0;
    while start != vector.len() {
        for index in (start .. vector.len()) {
            match vector[index] < vector[start] {
                true  => vector.swap(index, start),
                false => println!("false"), // do nothing
            }
        }
        start += 1;
    }
    vector
}

---

您的问题可以简化为以下内容（请查看并遵循如何在此处提问时创建一个）：

T

和

&T

是不同的类型

最终，您的代码现在没有意义。要将

&Vec

转换为

Vec

，您需要克隆它：

fn selection_sort(vector: &Vec<i32>) -> Vec<i32> {
    let mut vector = vector.clone();
    let mut start = 0;
    while start != vector.len() {
        for index in (start .. vector.len()) {
            match vector[index] < vector[start] {
                true  => vector.swap(index, start),
                false => println!("false"), // do nothing
            }
        }
        start += 1;
    }
    vector
}

---

那会节省我很多打字时间。。无论如何，我知道这两种类型是不同的，但我不知道如何复制它的值。如果我理解正确，最好使用向量的引用片，而不是向量的引用。对向量进行切片不是额外的计算吗？如果我使用的参考向量和参考片的内存量是一样的，那么从参考到向量创建一个片是非常便宜的。切片是指向数据的直接指针，

&Vec

对于接受它的函数有一个额外的间接指向。谢谢你们，你们的回答非常有用实际上，a

&T]

比a

&Vec

更有用。从技术上讲，我确实认为这是一个稍微多一点的计算，但它更能接受各种类型（

Vec

和数组，仅举两例）。这将节省我大量的打字时间。。无论如何，我知道这两种类型是不同的，但我不知道如何复制它的值。如果我理解正确，最好使用向量的引用片，而不是向量的引用。对向量进行切片不是额外的计算吗？如果我使用的参考向量和参考片的内存量是一样的，那么从参考到向量创建一个片是非常便宜的。切片是指向数据的直接指针，

&Vec

对于接受它的函数有一个额外的间接指向。谢谢你们，你们的回答非常有用实际上，a

&T]

比a

&Vec

更有用。从技术上讲，我确实认为这是一个稍微多一点的计算，但它更能接受各种类型（

Vec

和数组，举两个例子）。

fn selection_sort(vector: &Vec<i32>) -> Vec<i32> {
    let mut vector = vector.clone();
    let mut start = 0;
    while start != vector.len() {
        for index in (start .. vector.len()) {
            match vector[index] < vector[start] {
                true  => vector.swap(index, start),
                false => println!("false"), // do nothing
            }
        }
        start += 1;
    }
    vector
}

fn selection_sort(vector: &[i32]) -> Vec<i32> {
    let mut vector = vector.to_vec();
    // ...
}