如何在构造函数上正确使用 std::enable_if

Question

这道题结合了好几段代码，有点复杂，不过我尽量精简了。

我正在尝试使用 std::enable_if 有条件地调用正确的构造函数，因为当使用 lambda 表达式作为输入时函数签名不明确，但所述 lambda 表达式的参数可以隐式转换为一个另一个。

这是基于以下问题的尝试：, but is sufficiently different and focuses on std::enable_if to merit another question. I am also providing the Live Example 解决问题部分已被注释掉。

为了检查仿函数的参数（和结果）类型，我有以下 class：

template <typename T>
struct function_traits
    : public function_traits<decltype(&T::operator())>
{};
// For generic types, directly use the result of the signature of its 'operator()'

template <typename ClassType, typename ReturnType, typename... Args>
struct function_traits<ReturnType(ClassType::*)(Args...) const>
    // we specialize for pointers to member function
{
    enum { num_args = sizeof...(Args) };

    typedef ReturnType result_type;

    template <size_t N>
    struct arg
    {
        typedef typename std::tuple_element<N, std::tuple<Args...>>::type type;
        // the i-th argument is equivalent to the i-th tuple element of a tuple
        // composed of those arguments.
    };
};

然后我尝试运行下面的代码，但是， std::enable_if 部分似乎不起作用，但我知道括号内的所有内容都（或应该）工作，如Live Example.

template<typename data_type, typename Type1, typename Type2>
class A
{
public:
    using a_type = std::tuple<Type1, Type2>;
    using b_type = std::tuple<std::size_t,std::size_t>;

    template<typename Lambda, typename = std::enable_if_t<std::is_same<typename function_traits<Lambda>::arg<0>::type, b_type>::value>>
    A(const Lambda& Initializer)
    {
        std::cout << "idx_type" << std::endl;
    }
    template<typename Lambda, typename = std::enable_if_t<std::is_same<typename function_traits<Lambda>::arg<0>::type, a_type>::value>>
    A(const Lambda& Initializer)
    {
        std::cout << "point_type" << std::endl;
    }
};

int main()
{
    auto f = [](std::tuple<long long, int>) -> double { return 2; };

    std::cout << std::is_same<typename function_traits<decltype(f)>::arg<0>::type, std::tuple<std::size_t, std::size_t>>::value
        << std::is_same<typename function_traits<decltype(f)>::arg<0>::type, std::tuple<long long, int>>::value;

    auto a = A<double, long long, int>{
        [](std::tuple<long long, int>) -> double { return 1; }
    };

    auto b = A<double, long long, int>{
        [](std::tuple<std::size_t, std::size_t>) -> double { return 2; }  
    };

}

那我错过了什么？我正在处理示例 #5 here。

Answer 1

从属姓名

typename function_traits<Lambda>::template arg<0>::type
                                  ^^^^^^^^

有关从属名称以及何时需要 template 或 typename 的更多信息，请参阅 this post。

`enable_if`

typename = std::enable_if_t<condition>

应该是

std::enable_if_t<condition>* = nullptr

如@Jarod42 所述。这是因为否则构造函数将是相同的并且无法重载。它们的默认值不同并不会改变这一事实。有关详细信息，请参阅。

合起来就是

template<typename Lambda, std::enable_if_t<std::is_same_v<typename function_traits<Lambda>::template arg<0>::type, a_type>>* = nullptr>
A(const Lambda&);

Live

旁注

function_traits 不适用于重载或模板化 operator()，它可以被替换

template<typename T, typename... Args>
using return_type = decltype(std::declval<T>()(std::declval<Args>()...));

template<typename T, typename... Args>
using mfp = decltype(static_cast<return_type<T, Args...>(T::*)(Args...) const>(&T::operator()));

template<typename Lambda, mfp<Lambda, a_type> = nullptr>
A(const Lambda&);

检查是否可以在不进行转换的情况下使用准确的参数调用可调用对象。

如何在构造函数上正确使用 std::enable_if

How to properly use std::enable_if on a constructor

c++

enable-if

template-meta-programming

从属姓名

`enable_if`

旁注