如何实现C++函数参数自动匹配，支持任意顺序调用

问题场景 #

代码中存在大量接收多个const&类型配置参数的函数。由于C++仅支持位置参数，最初采用共享配置字典（map）传递参数，但随着代码规模增长，无法追踪各函数使用的具体参数。

改用分组结构体替代字典后，部分函数仍需接收多个结构体参数。约定固定传递顺序（如字母序）虽能减少混淆，但在部分场景下不符合逻辑习惯。需求是实现任意顺序传递结构体参数，保留编译时类型检查，且避免过度复杂的模板元编程（代码量控制在百行以内）。

已知curry函数已有成熟实现，目标是写出callWithAnyOrderOfParameters函数，让以下代码可正常编译：

原错误示例代码 #

#include <string>
#include <vector>

struct ConfigParsA {
    std::string somePath;
    long numberOfIterations;
    // ...其他成员
};

struct ConfigParsB { /* ...成员 */ };
struct ConfigParsC { /* ...成员 */ };

struct Result { /* ...成员 */ };

Result functionThatUsesLotsOfArguments(long l1, const std::vector<int>& v1, 
                                       const ConfigParsA& p1, const ConfigParsB& p2, const ConfigParsC& c3);

int main() {
    ConfigParsA par1{"/home/user/file.csv", 1000/*, ...*/};
    ConfigParsB par2{/*...*/};
    ConfigParsC par3{/*...*/};
    std::vector<int> vec{1,2,3,4};

    // 编译错误：参数顺序不符合函数定义
    auto result = functionThatUsesLotsOfArguments(42, vec, par2, par3, par1); 
}

期望的正确使用方式 #

int main() {
    ConfigParsA par1{"/home/user/file.csv", 1000/*, ...*/};
    ConfigParsB par2{/*...*/};
    ConfigParsC par3{/*...*/};
    std::vector<int> vec{1,2,3,4};

    auto curried_f = curry(functionThatUsesLotsOfArguments)(42, vec);
    // 任意顺序传递剩余结构体参数，编译通过
    auto result = callWithAnyOrderOfParameters(curried_f, par2, par3, par1); 
}

简洁实现方案 #

针对特定场景的极简实现 #

如果明确知道curried_f需要接收的剩余参数类型（如ConfigParsA、ConfigParsB、ConfigParsC），可以直接写出几行核心代码：

#include <tuple>

// 从tuple中按类型提取元素（依赖类型唯一性）
template<typename T, typename Tuple>
constexpr decltype(auto) get_by_type(Tuple&& t) {
    return std::get<T>(std::forward<Tuple>(t));
}

// 核心函数：将传入的参数打包后按目标类型顺序提取，调用curried函数
template<typename CurriedFunc, typename... Args>
auto callWithAnyOrderOfParameters(CurriedFunc&& f, Args&&... args) {
    auto args_tuple = std::make_tuple(std::forward<Args>(args)...);
    return std::forward<CurriedFunc>(f)(
        get_by_type<ConfigParsA>(args_tuple),
        get_by_type<ConfigParsB>(args_tuple),
        get_by_type<ConfigParsC>(args_tuple)
    );
}

通用自动推导版本 #

如果需要适配任意curried函数，可利用C++17的模板特性自动推导剩余参数类型（假设curry返回std::function类型）：

#include <tuple>
#include <functional>
#include <type_traits>

// 按类型提取tuple元素
template<typename T, typename Tuple>
constexpr decltype(auto) get_by_type(Tuple&& t) {
    return std::get<T>(std::forward<Tuple>(t));
}

// 提取std::function的参数类型
template<typename Func>
struct function_args;

template<typename R, typename... Args>
struct function_args<std::function<R(Args...)>> {
    using type = std::tuple<Args...>;
};

template<typename Func>
using function_args_t = typename function_args<Func>::type;

// 通用版核心函数
template<typename CurriedFunc, typename... Args>
auto callWithAnyOrderOfParameters(CurriedFunc&& f, Args&&... args) {
    using ArgsTuple = function_args_t<std::decay_t<CurriedFunc>>;
    auto input_args = std::make_tuple(std::forward<Args>(args)...);

    // 折叠表达式：按curried函数的参数类型顺序提取输入参数
    return std::apply([&f](auto&&... params) {
        return std::forward<CurriedFunc>(f)(std::forward<decltype(params)>(params)...);
    }, std::make_tuple(
        get_by_type<std::decay_t<decltype(std::get<N>(std::declval<ArgsTuple>()))>>(input_args)...
    ));
}

关键注意事项 #

1. 类型唯一性：必须满足题目假设的「每个参数类型唯一且不可相互转换」，否则std::get<T>会产生歧义编译错误。
2. 编译时安全：若缺少必要类型参数或传入错误类型，会直接触发编译错误，避免运行时问题。
3. curry适配：通用版本依赖curry返回std::function类型，若你的curry返回lambda，可调整function_args结构体来推导lambda的参数类型。
4. 代码简洁性：核心逻辑仅数十行，无复杂模板嵌套，符合需求。

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