c++ - 给定一个已经定义的模板函数，是否可以用另一个模板函数重载它而不会产生歧义？

Question

有一个库定义了一个模板函数，以确保它被重载或专门用于您使用的任何类型，否则将导致静态断言失败。

我想用另一个模板函数替换它，该模板函数适用于原始模板可以接受的类型的子集。是否可以在不修改库中源代码的情况下这样做？

例子:

#include <type_traits>

// used for static_assert
template <typename T>
struct always_false : std::false_type {};

namespace OWNER { namespace LIB_API {
  // function defined in some other library:
  template <typename T>
  void fn(T const&)
  {
      static_assert(always_false<T>::value, "Must override or specialize.");
  }
}}
// defined types in my source:
struct should_work { /*...*/ };

struct should_not_work { /*...*/ };

// specify a function with parameter
void this_fn(should_work const &) { /*...*/ }

// my test for a function with the signature this_fn(T const&)
template <typename T>
using has_fns = std::void_t<decltype(this_fn(std::declval<T>()))>;

namespace OWNER { namespace LIB_API {
  // my generic override for a subset of types in T
  template <typename T, typename = has_fns<T>>
  void fn(T const&) { /*...*/ }
}}

void test()
{
    fn(should_work());      // Should run my generic code.
    fn(should_not_work());  // Should cause a static assert failure
}

这段代码当然不起作用，并且会导致对 OWNER::LIB_API::fn(T&) 错误的模糊调用。有没有可能让它变得明确？请注意，我的代码和库调用了 OWNER::LIB_API::fn(T&)。

Answer 1

做你想做的事情的一种方法(实际上可能是唯一的方法)是重载 fn 以便它接受一种特殊的包装器。

template< class, class = std::void_t<> >
struct has_fns : std::false_type { };

template< class T >
struct has_fns<T, std::void_t<decltype(this_fn(std::declval<T>()))>> : std::true_type { };


template <class T, class has = has_fns<T>>
struct fns_wrapper
{
   T const& t;
   fns_wrapper(T const& t) : t(t) {
       static_assert(has::value, "Wrapper only works for types with this_fn");
   };
};

namespace LIB_API {
  template <class T>
  void fn(fns_wrapper<T> wrapper) { this_fn(wrapper.t); }
}

然后

    fn(fns_wrapper(should_work()));        // runs generic code.
//  fn(should_not_work());                 // fails with static assertion
//  fn(fns_wrapper(should_not_work()));    // fails with another static assertion