Vector 什么'；使用两个向量创建新向量的好方法是什么？

我想要一个很好的函数来创建一个新的向量，并传达参数向量不再相关并且应该被销毁的信息，获取它们的所有权。我并不特别想让两个参数都是可变的（使用

append

、

extend

、或

push_all

，从而更改调用签名）。代码（）：

fn main（）{
设arg1=vec！[1,2,3]；
设arg2=vec！[4,5,6]；
让所需=消耗_和_concat（arg1，arg2）；
断言（需要，vec！[1,2,3,4,5,6]）；
}
fn消耗_和_concat（vec1:Vec，vec2:Vec）->Vec{
//这里有好吃的吗
}

---

我知道对于

Vec

s没有

+

。在Ruby中，我会做

vec1+vec2

或

vec1.concat（vec2）

或

[vec1，vec2]。展平。有没有同样优雅的东西我不知道呢？
我想你在找

在这里，我们可以重用从
arg1
分配的空间，但是通过
arg2
分配的空间无法有效地执行任何操作。对于一个更具体于原始问题的示例：

fn main() {
    let arg1 = vec![1, 2, 3];
    let arg2 = vec![4, 5, 6];
    let desired = consume_and_concat(arg1, arg2);
    assert_eq!(desired, vec![1, 2, 3, 4, 5, 6]);
}

fn consume_and_concat(mut vec1: Vec<i32>, vec2: Vec<i32>) -> Vec<i32> {
    vec1.extend(vec2);
    vec1
}

fn main（）{
设arg1=vec！[1,2,3]；
设arg2=vec！[4,5,6]；
让所需=消耗_和_concat（arg1，arg2）；
断言（需要，vec！[1,2,3,4,5,6]）；
}
fn消费和消费（mut vec1:Vec，vec2:Vec）->Vec{
vec1.扩展（vec2）；
vec1
}
您不需要它们中的任何一个是可变的，尽管如果其中一个是可变的，您可以在重新分配时节省一点时间。对于铁锈来说，一件好事就是你不必说它会腐蚀它。从函数签名就可以看出这一点。因为它没有引用，这意味着该函数拥有所有权

fn main() {
    let vec1 = vec![1, 2, 3];
    let vec2 = vec![4, 5, 6];
    let concatenated_vecs = consume_and_concat(vec1, vec2);
    for num in concatenated_vecs {
        println!("{}", num);
    }
}

fn consume_and_concat(vec1: Vec<i32>, vec2: Vec<i32>) -> Vec<i32> {
    let mut result : Vec<i32> = vec![];
    result.extend(vec1);
    result.extend(vec2);
    result
}

fn main（）{
设vec1=vec！[1,2,3]；
设vec2=vec！[4,5,6]；
让串联的_vecs=消耗_和_concat（vec1，vec2）；
对于串联向量中的num{
println！（“{}”，num）；
}
}
fn消耗_和_concat（vec1:Vec，vec2:Vec）->Vec{
让mut结果：Vec=Vec！[]；
结果：扩展（vec1）；
结果：扩展（vec2）；
结果
}
我想指出，在签名中标记参数
mut
是不必要的；这只是一条捷径

因此，我们可以在不修改签名的情况下实现预期结果：

fn consume_and_concat(vec1: Vec<i32>, vec2: Vec<i32>) -> Vec<i32> {
    let mut vec1 = vec1;
    vec1.extend(vec2);
    vec1
}

正如您已经意识到的，
vec1
is
mut
不会改变其参数的类型，因此也不会改变传递参数的方式。我想我必须添加
mut
，这样调用者将是
consum_和_concat（mut arg1，arg2）
。所以我想这没关系。。。
extend
没有返回
self
，因此它是可链接的，可以直接返回……还有一个（不稳定的）设计允许数据结构（几个实现了它）利用它们自己的内部不变量来提高效率，例如，
Vec:：append
可以只是一个
memcpy
“我想指出，在签名中标记一个参数mut是不必要的；它只是一个快捷方式。”→ 这是因为可变性是堆栈位置的属性，而不是拥有的对象。当移动到另一个位置时，所拥有的数据可能会变。最近向我指出的一件事是，函数参数中的
mut
关键字没有显示在rustdoc中，因此它实际上是一个内部实现细节。自从知道了这一点，我就更有可能使用它。@Shepmaster:哦，太好了！谢谢你的宣传！我认为这个答案不够优雅，因为你扔掉了
vec1
的分配空间，强制重新分配和复制这些内容。是的，我理解所有权和消费。我加入这些细节是为了明确我正在寻找具有函数签名的解决方案
（vec1:Vec，vec2:Vec）->Vec
，而不是
（vec1:&Vec，vec2:&Vec）->Vec
@Shepmaster我同意。我这样写是为了匹配所需的函数签名。
fn main() {
    let vec1 = vec![1, 2, 3];
    let vec2 = vec![4, 5, 6];
    let concatenated_vecs = consume_and_concat(vec1, vec2);
    for num in concatenated_vecs {
        println!("{}", num);
    }
}

fn consume_and_concat(vec1: Vec<i32>, vec2: Vec<i32>) -> Vec<i32> {
    let mut result : Vec<i32> = vec![];
    result.extend(vec1);
    result.extend(vec2);
    result
}

fn consume_and_concat(vec1: Vec<i32>, vec2: Vec<i32>) -> Vec<i32> {
    let mut vec1 = vec1;
    vec1.extend(vec2);
    vec1
}

fn consume_and_concat(mut vec1: Vec<i32>, vec2: Vec<i32>) -> Vec<i32> {
    vec1.extend(vec2);
    vec1
}