C++中如何重排模板函数参数以正确调用目标函数

核心思路 #

完全在编译期完成三步操作，无运行时额外开销：

• 萃取目标函数BFunc的参数类型顺序，作为参数重排的匹配规则
• 将AFunc收到的所有入参按传入顺序打包为带左值引用的元组，避免参数拷贝
• 对BFunc要求的每一个位置的参数类型，在打包的参数元组中匹配对应类型的入参，按目标顺序取出后调用BFunc

该方案基于题目给出的前提：两个函数的参数类型集合完全一致、同类型参数无重复，因此按类型匹配索引的方式不存在歧义，且天然支持任意数量的参数，不受示例中3个参数的限制。

具体实现代码 #

基础工具组件 #

#include <tuple>
#include <utility>
#include <type_traits>

// 函数参数类型萃取工具
template <typename T>
struct FuncTraits;

template <typename Ret, typename... Args>
struct FuncTraits<Ret(Args...)> {
    // 按BFunc要求的顺序存储所有参数类型
    using ArgsList = std::tuple<Args...>;
    static constexpr size_t ArgCount = sizeof...(Args);
};

// 编译期在元组中查找指定类型的元素索引
template <typename Target, typename Tuple, size_t CurIdx = 0>
constexpr size_t FindMatchedIndex() {
    if constexpr (std::is_same_v<Target, std::tuple_element_t<CurIdx, Tuple>>) {
        return CurIdx;
    } else {
        static_assert(CurIdx + 1 < std::tuple_size_v<Tuple>, "未找到匹配类型的入参，请检查参数集合是否一致");
        return FindMatchedIndex<Target, Tuple, CurIdx + 1>();
    }
}

// 重排参数并调用目标函数的核心逻辑
template <typename... BFuncRequiredArgs, typename... InputArgs>
void ReorderAndCall(InputArgs&... input_args) {
    // 按传入顺序打包入参的左值引用
    auto input_tuple = std::forward_as_tuple(input_args...);
    using TargetArgList = std::tuple<BFuncRequiredArgs...>;

    // 为BFunc的每个参数位置生成对应的输入参数索引
    auto index_seq = []<size_t... Pos>(std::index_sequence<Pos...>) {
        return std::index_sequence<FindMatchedIndex<
            std::tuple_element_t<Pos, TargetArgList>,
            decltype(input_tuple)
        >()...>{};
    }(std::make_index_sequence<sizeof...(BFuncRequiredArgs)>{});

    // 按目标顺序取出参数并调用BFunc
    auto call_impl = [&]<size_t... RealPos>(std::index_sequence<RealPos...>) {
        BFunc(std::get<RealPos>(input_tuple)...);
    };
    call_impl(index_seq);
}

适配示例代码的版本 #

// 目标函数BFunc
void BFunc(int, double, char) {
    /* 业务逻辑 */
}

// 通用变参模板AFunc，支持任意顺序、任意数量的同类型参数集合
template <typename... Args>
void AFunc(Args&... args) {
    // 萃取BFunc的要求参数列表
    using BFuncArgs = typename FuncTraits<decltype(BFunc)>::ArgsList;
    // 展开BFunc的参数类型列表，传入重排逻辑
    std::apply([&]<typename... BArgs>(std::tuple<BArgs...>) {
        ReorderAndCall<BArgs...>(args...);
    }, BFuncArgs{});
}

调用验证 #

以下所有调用均无需手动调整参数顺序，可自动完成类型匹配与顺序重排：

int a = 10;
double b = 3.14;
char c = 'x';

AFunc(b, a, c);  // 模板参数<double, int, char>，自动重排为(int, double, char)传入BFunc
AFunc(a, b, c);  // 顺序和BFunc要求一致，直接透传
AFunc(c, b, a);  // 模板参数<char, double, int>，自动重排顺序
AFunc(c, a, b);  // 模板参数<char, int, double>，自动重排顺序

注意事项 #

• 整个重排过程完全在编译期完成，参数传递全程保留左值引用，不会产生不必要的拷贝，性能与手动按正确顺序传参完全一致
• 如果两个函数存在同类型重复参数，这种按类型匹配的方式会产生歧义，需要额外传入顺序映射规则，不过该场景不在题目给出的前提范围内

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