不同编程语言函数接收不定数量参数实现方法咨询

没问题！我整理了你提到的这些主流编程语言里实现不定数量参数的方法，对照你熟悉的Wolfram Language写法，应该能帮你快速对比选型：

C语言 #

C通过<stdarg.h>头文件实现可变参数，需要固定一个起始参数来标记可变参数的数量（或用特殊值如NULL收尾）：

#include <stdio.h>
#include <stdarg.h>

// 接收不定数量整数，计算总和
int sum(int count, ...) {
    va_list args;
    va_start(args, count); // 初始化可变参数列表
    int total = 0;
    for (int i = 0; i < count; i++) {
        total += va_arg(args, int); // 按类型逐个取出参数
    }
    va_end(args); // 清理资源
    return total;
}

int main() {
    printf("%d\n", sum(3, 1, 2, 3)); // 输出6
    return 0;
}

⚠️ 注意：C的可变参数没有类型检查，需要手动确保参数类型和数量正确。

C++ #

C++提供了多种更灵活的实现方式，其中模板参数包是类型安全的首选：

1. 模板参数包（C++11+）：支持任意类型和数量的参数

#include <iostream>
#include <vector>

// 模拟Wolfram里的不定参数收集
template<typename... Args>
auto collect(Args... args) {
    return std::vector{args...};
}

// 处理两类不定参数的求和（C++17折叠表达式简化写法）
template<typename... Xs, typename... Ys>
auto sum_two_groups(Xs... xs, Ys... ys) {
    return (0 + ... + xs) + (0 + ... + ys);
}

int main() {
    auto vec = collect(1, "hello", 3.14);
    std::cout << sum_two_groups(1,2,3, 4,5) << std::endl; // 输出15
    return 0;
}

2. 也可以用std::initializer_list接收同类型的不定参数，适合参数类型统一的场景。

Java #

Java用...语法实现可变参数（varargs），可变参数必须是函数的最后一个参数，会自动转为数组：

public class VarargsDemo {
    // 接收不定数量字符串并打印
    public static void printStrings(String... args) {
        for (String s : args) {
            System.out.println(s);
        }
    }

    // 处理两类不定参数：Java不支持多个varargs，所以用数组传递分组参数
    public static int sumTwoGroups(int[] group1, int[] group2) {
        int total = 0;
        for (int num : group1) total += num;
        for (int num : group2) total += num;
        return total;
    }

    public static void main(String[] args) {
        printStrings("a", "b", "c");
        System.out.println(sumTwoGroups(new int[]{1,2,3}, new int[]{4,5})); // 输出15
    }
}

Python #

Python用*args接收不定数量的位置参数，**kwargs接收关键字参数。如果需要两类不定参数，可以通过参数解包或列表分组实现：

# 模拟Wolfram的不定参数收集
def collect(*args):
    return list(args)

# 两类不定参数求和：直接传入两个列表
def sum_two_groups(group1, group2):
    return sum(group1) + sum(group2)

# 或者通过拆分参数列表实现（需约定拆分规则）
def sum_two_groups_unpack(*args):
    split_at = 3
    return sum(args[:split_at]) + sum(args[split_at:])

print(collect(1, "hello", 3.14)) # 输出[1, 'hello', 3.14]
print(sum_two_groups([1,2,3], [4,5])) # 输出15
print(sum_two_groups_unpack(1,2,3,4,5)) # 输出15

Ruby #

Ruby用*（splat运算符）处理可变参数，参数会转为数组：

# 不定参数收集
def collect(*args)
  args
end

# 两类不定参数求和：传入两个数组
def sum_two_groups(group1, group2)
  group1.sum + group2.sum
end

# 拆分参数列表实现分组
def sum_two_groups_unpack(*args)
  group1, group2 = args.take(3), args.drop(3)
  group1.sum + group2.sum
end

puts collect(1, "hello", 3.14).inspect # 输出[1, "hello", 3.14]
puts sum_two_groups([1,2,3], [4,5]) # 输出15
puts sum_two_groups_unpack(1,2,3,4,5) # 输出15

Ruby 2.7+还支持关键字参数的splat（**kwargs），适合更清晰的参数分组场景。

Perl #

Perl中所有参数默认存放在@_数组里，可手动提取和分组：

use Data::Dumper;

# 不定参数收集（返回数组引用）
sub collect {
    my @args = @_;
    return \@args;
}

# 两类不定参数求和：传入数组引用
sub sum_two_groups {
    my ($group1_ref, $group2_ref) = @_;
    my $total = 0;
    $total += $_ for @$group1_ref;
    $total += $_ for @$group2_ref;
    return $total;
}

# 拆分@_实现分组
sub sum_two_groups_unpack {
    my @args = @_;
    my @group1 = splice @args, 0, 3; # 取前3个作为第一组
    my $total = 0;
    $total += $_ for @group1;
    $total += $_ for @args;
    return $total;
}

print Dumper(collect(1, "hello", 3.14)); # 输出数组引用
print sum_two_groups([1,2,3], [4,5]) . "\n"; # 输出15
print sum_two_groups_unpack(1,2,3,4,5) . "\n"; # 输出15

内容的提问来源于stack exchange，提问作者user6813084