Choose Function Through Metaprogramming

Choose Function Through Metaprogramming

本文关键字：Metaprogramming Through Function Choose      更新时间：2023-10-16

假设用户可能提供也可能不提供以下两个功能：

void foo(int) { std::cout << "foo int" << std::endl; }
void foo() { std::cout << "foo void" << std::endl; }

在我的实现中，如果用户定义了foo(int)，我想调用它，否则我想调用foo()。这可以按如下方式进行：

template<class Int> auto call_foo(Int i) -> decltype(foo(i)) { return foo(i); }
template<class... Int> void call_foo(Int... i) { return foo(); }

然而，如果我们想做相反的事情，即更喜欢foo()而不是foo(int)，那么下面的天真尝试是行不通的。

template<class Int> auto call_foo(Int i) -> decltype(foo()) { return foo(); }
template<class... Int> void call_foo(Int... i) { return foo(i...); }

问题是decltype(foo())不依赖于Int，因此foo()的可能不存在不会导致SFINAE。

一个可能的解决方案是要求用户定义

void foo(int, void*) { std::cout << "foo int" << std::endl; }
void foo(void*) { std::cout << "foo void" << std::endl; }

像这样，我们总是有一个参数foo，我们可以在上面做"模板与参数包"的把戏。虽然这在技术上解决了这个问题，但它非常丑陋，因为它需要用户获取一个对他/她来说意义可能不明显的附加参数。那么，有没有一种方法可以在没有附加参数的情况下实现相同的效果？

不需要SFINAE。只要标准的过载分辨率就足够了。

void call_func(void (*f)(), int) { f(); } // #1
template<class = void>
void call_func(void (*f)(int), int x) { f(x); } // #2
call_func(foo, 1); // #1 is preferred if viable. All others being equal,
                   // non-templates are preferred over templates

以下可能会有所帮助：

template<typename ... Ts> void foo(Ts...) = delete;
void foo(int) { std::cout << "foo int" << std::endl; }
//void foo() { std::cout << "foo void" << std::endl; }
namespace detail
{
struct overload_priority_low {};
struct overload_priority_high : overload_priority_low{};
template <typename Int>
auto call_foo(Int i, overload_priority_low) -> decltype(foo(i)) { return foo(i); }
template <typename Int>
auto call_foo(Int , overload_priority_high) -> decltype(sizeof(Int), foo()) { return foo(); }
}
void call_foo(int i)
{
    return detail::call_foo(i, detail::overload_priority_high{});
}

活生生的例子。

相关文章：