Rust 移动a&；[&；str]插入到线程中

正如标题所说，我正在尝试将

&[&str]

移动到线程中。实际上，下面的代码是有效的，但我有两个问题：

让args2:Vec=args.iter（）.map（|arg |{arg.to_string（）}）.collect（）&[&str]

转换为

Vec

似乎有点冗长。这能做到“更好”吗

如果我理解正确，字符串会被复制两次：首先是通过

let cmd2

和

let args2

语句；然后将它们移动到

move

闭包中。这是正确的吗？如果是的话，是否可以用一份副本来完成

我知道

thread:：scoped

，但目前不推荐使用。我编写此代码也是为了学习更多关于生锈的知识，所以对“不可靠”代码的评论也很感激

use std::process::{Command,Output};
use std::thread;
use std::thread::JoinHandle;

pub struct Process {
    joiner: JoinHandle<Output>,
}

impl Process {
    pub fn new(cmd: &str, args: &[&str]) -> Process {
        // Copy the strings for the thread
        let cmd2 = cmd.to_string();
        let args2: Vec<_> = args.iter().map(|arg| { arg.to_string() }).collect();

        let child = thread::spawn(move || {
            Command::new(cmd2).args(&args2[..]).output().unwrap_or_else(|e| {
                panic!("Failed to execute process: {}", e)
            })
        });
        Process { joiner: child }
    }
}

使用std:：process:：{Command，Output}；
使用std：：线程；
使用std:：thread:：JoinHandle；
发布结构进程{
joiner:JoinHandle，
}
impl过程{
pub fn new（cmd:&str，args:&[&str]）->进程{
//复制线程的字符串
让cmd2=cmd.to_string（）；
设args2:Vec=args.iter（）.map（| arg |{arg.to_string（）}）.collect（）；
让孩子=线程：：繁殖（移动| |{
Command:：new（cmd2）.args（&args2[…]）.output（）.unwrap_或_else（| e|{
死机！（“无法执行进程：{}”，e）
})
});
进程{joiner:child}
}
}

让args2:Vec=args.iter（）.map（|arg |{arg.to_string（）}）.collect（）
我不这么认为。这方面有一些小的变化（例如，
args.iter（）.cloned（）.map（String:：from）.collect（）；
），但我想不出比这更好的。一个小问题是，使用
to_string
将
&str
转换为
字符串
的效率不如使用
string:：from
或
转换为

如果我理解正确，字符串会被复制两次：首先是let cmd2和let args2语句；然后将它们移动到移动闭包中。这是正确的吗？如果是的话，是否可以用一份副本来完成

否，仅在调用
到\u string
的位置复制字符串。字符串不实现
Copy
，因此它们永远不会被隐式复制。如果在字符串移动到闭包后尝试访问这些字符串，则会出现编译器错误。
感谢
String:：from
。对于第二点，我首先显式地将字符串复制到
cmd2
和
args2
中，但是当它们被移动到闭包中时，它们不是也在线程堆栈上物理复制吗？@Garogolun嗯，向量被复制了，但这只是一个浅拷贝（即包含指针、长度和容量的结构）。未复制向量的内容。线程可以访问向量的内容。但是，如果
Process:：new
返回，向量及其内容将被破坏。那么这不是不安全吗？@Garogolun不，向量的内容不会在
过程：：new
结束时被销毁，因为向量已被移动到闭包中，这意味着清理向量已成为闭包的责任。啊，显然我错误地认为向量的内容也存在于堆栈中。非常感谢。