Question

为什么我们仍然使用结构和typedef s（或using s）进行元编程？

查看此问题中的代码 - Inferring the call signature of a lambda or arbitrary callable for "make_function"：

template<typename T> struct remove_class { };
template<typename C, typename R, typename... A>
struct remove_class<R(C::*)(A...)> { using type = R(A...); };

template<typename T, bool> struct get_signature_impl { };
template<typename R, typename... A>
struct get_signature_impl<R(A...), true> { using type = R(A...); };
template<typename R, typename... A>
struct get_signature_impl<R(*)(A...), true> { using type = R(A...); };
template<typename T>
struct get_signature_impl<T, true> { using type = typename remove_class<
    decltype(&std::remove_reference<T>::type::operator())>::type; };

有许多奇怪的技巧，例如bool，嘈杂的关键字，例如typename，冗余的内容，例如struct get_signature_impl;。
很高兴我们在C ++ 11中获得了using关键字，但它没有太大区别。

在C ++ 11中，我们有decltype和trailing-return-type。有了这种力量，我们就可以放弃所有丑陋的元结构，并编写漂亮的元函数。
所以，我们可以重写上面的代码：

template<typename C, typename R, typename... A> auto make_function_aux(R(C::*)(A...)) -> std::function<R(A...)>;
template<typename C, typename R, typename... A> auto make_function_aux(R(C::*)(A...) const) -> std::function<R(A...)>;
template<typename R, typename... A> auto make_function_aux(R(A...)) -> std::function<R(A...)>;
template<typename R, typename... A> auto make_function_aux(R(*)(A...)) -> std::function<R(A...)>;
template<typename T> auto make_function_aux(const T&) -> decltype(make_function_aux(&T::operator()));

template<typename F> auto make_function(F&& f) -> decltype(make_function_aux(f)) { return decltype(make_function_aux(f))(std::forward<F>(f)); }

是否有任何情况下模板部分特化比使用decltype的函数重载更好地匹配模板参数，或者这只是程序员惯性的情况？

Answer 1

我可以想到使用函数重载的一些问题：

不同的匹配规则;模板特化列表只会完全匹配，而如果参数可转换为参数类型，则函数重载将匹配。这通常可以解决，但在某些情况下可能会导致更复杂的元代码。

对退货类型的限制;函数不能返回某些类型，例如函数（不是函数指针），抽象类，不可复制类型（我认为），未知绑定数组（可能）。这可以通过将类型封装在模板结构中来解决。

一般来说，您可能会在一方使用typename和using之间进行权衡，另一方面可能会使用decltype和包装模板。< / p>

我同意你的上述代码是对原版的改进，仅用于消除bool技巧。

元结构与元功能

1 个答案: