Rust 如何创建参数数目可变的函数？

如何在Rust中创建参数数量可变的函数

如以下Java代码：

void foo(String... args) {
    for (String arg : args) {
        System.out.println(arg);
    }
}

---

一般来说，您不能-Rust不支持可变函数，除非与使用varargs的C代码进行互操作

在本例中，由于所有参数的类型相同，因此可以接受一个切片：

fn foo(args: &[&str]) {
    for arg in args {
        println!("{}", arg);
    }
}

fn main() {
    foo(&["hello", "world", "I", "am", "arguments"]);
}

（）

除此之外，您还可以显式接受可选参数：

fn foo(name: &str, age: Option<u8>) {
    match age {
        Some(age) => println!("{} is {}.", name, age),
        None      => println!("Who knows how old {} is?", name),
    }
}

fn main() {
    foo("Sally", Some(27));
    foo("Bill", None);
}

fn foo（姓名：&str，年龄：可选）{
比赛年龄{
Some（age）=>println！（“{}是{}.”，name，age），
None=>println！（“谁知道{}有多大岁数？”，name），
}
}
fn main（）{
傅（“莎莉”，约27岁）；
foo（“Bill”，无）；
}

（）

如果需要接受许多参数（可选或非可选），则可以实现生成器：

struct Arguments<'a> {
    name: &'a str,
    age: Option<u8>,
}

impl<'a> Arguments<'a> {
    fn new(name: &'a str) -> Arguments<'a> {
        Arguments {
            name: name,
            age: None
        }
    }

    fn age(self, age: u8) -> Self {
        Arguments {
            age: Some(age),
            ..self
        }
    }
}

fn foo(arg: Arguments) {
    match arg.age {
        Some(age) => println!("{} is {}.", arg.name, age),
        None      => println!("Who knows how old {} is?", arg.name),
    }
}

fn main() {
    foo(Arguments::new("Sally").age(27));
    foo(Arguments::new("Bill"));
}

struct参数{
fn new（name:&'a str）->Arguments
fn variable_func（_vargs:&[T]）{
fn main（）{
变量_func（&[1]）；
变量_func（&[1,2]）；
变量_func（&[“A”、“B”、“C”）；
}
在类型可能不同的一般情况下，可以使用宏：

macro\u规则！全部打印{
（$（$args:expr），*）=>{{
$(
println！（“{}”，$args）；
)*
}}
}
fn main（）{
打印所有！（1，2，“你好”）；
}


另一个例子是，如果您想折叠参数，可以执行以下操作：

宏规则！求和{
（$（$args:expr），*）=>{{
设结果=0；
$(
让结果=结果+$args；
)*
结果
}}
}
fn main（）{
断言（和）（1,2,3,6）；
}


另一个例子见。
@Shepmaster现在编译。是的，我同意分配部分。有没有类似的不分配的方法？啊，是的，这里真的不需要宏。我将根据您的评论修改答案。如果我想让函数拥有数组的所有权怎么办？@qiuxiafi，除非您可以硬编码数组的大小数组（因此它不是可变的），或者你为你想要支持的每一个
[T；N]
写一个变量，你必须给它一个
Vec
@kbolino是的，我认为Vec是唯一的解决方案。
fn variable_func<T>(_vargs: &[T]) {}

fn main() {
    variable_func(&[1]);
    variable_func(&[1, 2]);
    variable_func(&["A", "B", "C"]);
}