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

Question

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

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

这是在以下问题的基础上进行的尝试：Here，但与std::enable_if 有很大不同，因此值得提出另一个问题。我还提供了Live Example，它适用于注释掉的问题部分。

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

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 帖子。

enable_if

typename = std::enable_if_t<condition>

应该是

std::enable_if_t<condition>* = nullptr

正如@Jarod42 提到的。这是因为构造函数否则将是相同的并且无法重载。它们的默认值不同并不会改变这一事实。请参阅this 了解更多信息。

把它放在一起是

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&);

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