如何编写可推导N的函数，接受可变数量的array<double, N>参数？

你遇到的问题核心是让编译器自动推导所有array<double, N>参数的N值，同时确保所有参数的N一致。下面给你几个不同C++版本的实现方案，从基础到进阶：

基础版本（C++17+） #

这个版本利用第一个参数推导N，并用折叠表达式验证所有参数的类型一致性：

#include <array>
#include <type_traits>
#include <iostream>
using namespace std;

template<int N>
struct MyArray {};

// 第一个参数明确推导N，剩余参数必须是同类型的array<double, N>
template<int N, typename... Ts>
MyArray<N> foo(const array<double, N>& first, const Ts&... rest) {
    // 编译期检查：所有剩余参数都必须是array<double, N>
    static_assert((is_same_v<Ts, array<double, N>> && ...), 
                  "Error: All parameters must be array<double, N> with the same size N!");
    
    // 示例：遍历所有可变参数并打印数组大小（都是N）
    cout << "Array size: " << N << ", number of parameters: " << sizeof...(rest) + 1 << endl;
    (cout << "Processing array: ", ..., cout << rest.size() << " ");
    cout << endl;
    
    MyArray<N> result;
    return result;
}

int main() {
    array<double, 3> a, b, c;
    auto d = foo(a, b, c); // 自动推导N=3，返回MyArray<3>
    
    // 下面这行会触发编译错误（N不匹配），符合预期
    // array<double, 4> e;
    // auto f = foo(a, e);
}

关键细节： #

• 第一个参数const array<double, N>& first让编译器直接从传入的数组推导出N的值。
• static_assert配合折叠表达式(is_same_v<Ts, array<double, N>> && ...)，在编译期确保所有剩余参数的类型和第一个参数完全一致，避免传入不同大小的数组。
• 折叠表达式还能方便地展开可变参数做批量操作，比如示例中的打印逻辑。

兼容C++11的版本 #

如果你的编译器不支持C++17的折叠表达式，可以用递归模板实现类型检查：

#include <array>
#include <type_traits>
#include <iostream>
using namespace std;

template<int N>
struct MyArray {};

// 辅助模板：检查所有类型是否与T相同
template<typename T, typename... Ts>
struct AllSameType : true_type {};

template<typename T, typename U, typename... Ts>
struct AllSameType<T, U, Ts...> : 
    integral_constant<bool, is_same<T, U>::value && AllSameType<T, Ts...>::value> {};

template<int N, typename... Ts>
MyArray<N> foo(const array<double, N>& first, const Ts&... rest) {
    // 编译期检查所有参数类型一致
    static_assert(AllSameType<array<double, N>, Ts...>::value, 
                  "Error: All parameters must be array<double, N> with the same size N!");
    
    // C++11中处理可变参数可以用递归函数，比如：
    auto process = [](const auto& arr) { cout << arr.size() << " "; };
    process(first);
    // 递归展开的辅助函数（这里省略具体实现，你可以根据需求编写）
    // process_args(rest...);
    
    MyArray<N> result;
    return result;
}

int main() {
    array<double, 3> a, b, c;
    auto d = foo(a, b, c);
}

进阶版本（C++20+，用Concepts约束） #

C++20的概念（Concepts）能让代码更简洁、可读性更高，直接约束所有参数必须是array<double, N>类型：

#include <array>
#include <concepts>
#include <iostream>
using namespace std;

template<int N>
struct MyArray {};

// 定义概念：类型必须是array<double, N>
template<int N, typename T>
concept DoubleArrayOfSizeN = is_same_v<T, array<double, N>>;

// 用Concept约束所有参数，编译器自动推导N
template<int N>
MyArray<N> foo(const DoubleArrayOfSizeN<N> auto&... ts) {
    cout << "Array size: " << N << ", number of parameters: " << sizeof...(ts) << endl;
    
    // 展开可变参数做操作
    (cout << ts.size() << " ", ...);
    cout << endl;
    
    MyArray<N> result;
    return result;
}

int main() {
    array<double, 3> a, b, c;
    auto d = foo(a, b, c);
    
    // 同样，传入不同N的数组会触发编译错误
    // array<double, 4> e;
    // auto f = foo(a, e);
}

为什么这个方案更好？ #

• 用DoubleArrayOfSizeN概念直接约束参数类型，代码意图更清晰。
• 不需要依赖第一个参数推导N，编译器会自动从所有符合概念的参数中推导出统一的N值。

核心思路总结 #

1. 推导N的关键：必须让编译器能从参数中获取到N的具体值，要么通过第一个明确的array<double, N>参数，要么通过Concept约束所有参数的类型。
2. 类型一致性检查：通过static_assert或Concept确保所有传入的数组大小N完全相同，避免运行时错误。
3. 可变参数处理：根据C版本选择折叠表达式（C17+）或递归模板（C++11）来展开参数并执行批量操作。

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