如何在C++中获取构造函数参数类型并转为std::tuple？

需求说明 #

给定类：

struct MyClass {
    MyClass(int, double, std::string) {}
};

需要提取其构造函数的参数类型，生成对应的std::tuple<int, double, std::string>类型。

已知普通函数的参数类型可通过模板traits提取：

template <typename Func>
struct function_traits;

// 针对函数类型的特化
template <typename Ret, typename... Args>
struct function_traits<Ret(Args...)> {
    using args_tuple = std::tuple<Args...>;
};

但该方法无法直接适配构造函数，需要针对性实现。

约束条件 #

• 优先兼容C14/C17，也可接受C++20及以上方案
• 允许使用Boost等第三方库

实现方案 #

1. C14/C17：单构造函数场景的基础实现 #

利用构造函数指针的类型推导，结合模板特化实现：

#include <tuple>
#include <string>
#include <type_traits>

// 基础模板：匹配构造函数的函数类型
template <typename T>
struct ctor_traits;

template <typename Class, typename... Args>
struct ctor_traits<Class(Args...)> {
    using args_tuple = std::tuple<Args...>;
};

// 辅助模板：推导目标类的构造函数类型
template <typename Class>
struct get_ctor_args {
    // 仅适用于类只有一个公开构造函数的场景
    using type = typename ctor_traits<decltype(&Class::Class)>::args_tuple;
};

// 便捷别名
template <typename Class>
using ctor_args_tuple = typename get_ctor_args<Class>::type;

// 验证
struct MyClass {
    MyClass(int, double, std::string) {}
};

static_assert(std::is_same_v<ctor_args_tuple<MyClass>, std::tuple<int, double, std::string>>);

2. 多构造函数场景：选择参数最多的构造函数 #

若类存在多个构造函数，需要通过SFINAE和模板重载优先级，自动选择参数数量最多的构造函数，这也是Boost.DI的核心逻辑：

核心思路

定义一系列重载的模板函数，分别匹配不同参数数量的构造函数，编译器会优先选择最具体、参数数量最多的可行重载（因为模板匹配中，更具体的重载优先级更高）。

简化实现示例

#include <tuple>
#include <type_traits>

namespace detail {
    // 基础traits模板
    template <typename T>
    struct ctor_traits_impl;

    // 特化：存储参数类型tuple
    template <typename Class, typename... Args>
    struct ctor_traits_impl<Class(Args...)> {
        using args_tuple = std::tuple<Args...>;
    };

    // 重载测试函数：匹配0个参数的构造函数
    template <typename Class>
    static auto test_ctor(Class*) -> ctor_traits_impl<Class()>;

    // 匹配1个参数的构造函数
    template <typename Class, typename A1>
    static auto test_ctor(Class(*)(A1)) -> ctor_traits_impl<Class(A1)>;

    // 匹配2个参数的构造函数
    template <typename Class, typename A1, typename A2>
    static auto test_ctor(Class(*)(A1, A2)) -> ctor_traits_impl<Class(A1, A2)>;

    // 可扩展到更多参数（比如10个，覆盖绝大多数场景）
    template <typename Class, typename A1, typename A2, typename A3, typename A4, typename A5,
              typename A6, typename A7, typename A8, typename A9, typename A10>
    static auto test_ctor(Class(*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)) 
        -> ctor_traits_impl<Class(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)>;

    // 兜底：匹配0个参数
    static auto test_ctor(...) -> ctor_traits_impl<void()>;
}

// 对外接口
template <typename Class>
struct ctor_traits {
    using type = decltype(detail::test_ctor(static_cast<Class*>(nullptr)));
    using args_tuple = typename type::args_tuple;
};

// 便捷别名
template <typename Class>
using ctor_args_tuple = typename ctor_traits<Class>::args_tuple;

// 测试用例：多构造函数类
struct MultiCtorClass {
    MultiCtorClass() {}
    MultiCtorClass(int) {}
    MultiCtorClass(int, double, std::string) {}
};

// 验证：自动选择参数最多的构造函数
static_assert(std::is_same_v<ctor_args_tuple<MultiCtorClass>, std::tuple<int, double, std::string>>);

3. Boost.DI的实现逻辑解析 #

Boost.DI的ctor_traits.hpp核心逻辑与上述简化方案一致，主要做了以下优化：

• 通过递归模板生成任意数量的参数匹配重载（而非手动写固定数量）
• 利用std::is_constructible等类型特性做更精确的SFINAE判断
• 处理了私有构造函数、继承构造函数等边缘场景
• 支持模板类的构造函数参数提取

其核心是通过模板重载的优先级规则：当存在多个可行的构造函数匹配时，参数数量更多的重载模板会被编译器优先选择，从而实现"自动选参数最多的构造函数"的逻辑。

4. C++20简化方案 #

利用C++20的std::constructible_from和概念（Concepts），可以更简洁地实现参数提取：

#include <tuple>
#include <concepts>

namespace detail {
    template <typename Class, typename... Args>
    requires std::constructible_from<Class, Args...>
    auto get_ctor_args_helper() -> std::tuple<Args...>;

    // 递归选择参数最多的组合（这里省略具体递归逻辑，可通过模板参数包展开实现）
}

template <typename Class>
using ctor_args_tuple = decltype(detail::get_ctor_args_helper<Class>());

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