具有可变模板参数的成员函数的显式特化

Question

我正在编写一个模板化的事件处理程序，它允许用户将事件（以结构的形式）发送到连接的侦听器。

我有一个 "emit" 成员函数，它将根据提供的可变模板参数构造一个 Event 对象并转发事件。但是，我想提供一个专门的 "emit" 函数来检测提供的参数是否是一个预先构建的 Event 对象，在这种情况下我可以转发事件而无需制作多余的副本。

我的初步尝试...

template <typename T_Event>
class EventHandler
{
public:

  template <typename... T_Args>
  void emit(T_Args&&... args)
  {
    printf("variadic\n");
    deliver(T_Event {std::forward<T_Args>(args)...});
  }

  void emit(const T_Event& event)
  {
    printf("reference\n");
    deliver(event);
  }

  ...
};

我使用以下逻辑尝试了两个 emit 函数，但事实证明可变参数模板函数总是优先于 const 引用函数。

struct Event { int x; };

EventHandler<Event> handler;
Event event {1};
handler.emit(event);
handler.emit(2);

经过更多研究后，我设法通过定义两个版本的可变参数模板函数并使用 enable_if 执行正确的版本来实现我的目标。

  template <typename... T_Args>
  void emit(T_Args&&... args)
  {
    printf("variadic\n");
    T_Event event {std::forward<T_Args>(args)...};
    deliver(event);
  }

  template <typename... T_Args, typename = std::enable_if<std::is_same<const T_Event&, T_Args...>::value>>
  void emit(T_Args&&... args)
  {
    printf("reference\n");
    deliver(std::forward<T_Args>(args)...);
  }

当我用 GCC 编译时，这个解决方案完全符合我的需要，但是如果我用 CLANG 编译，我会收到以下错误消息：

  call to member function 'emit' is ambiguous
handler.emit(event);

  candidate function [with T_Args = <EventB &>]
void emit(T_Args&&... args)

  candidate function [with T_Args = <EventB &>,  =
  std::__1::enable_if<false, void>]
void emit(T_Args&&... args)

我假设我接近正确的解决方案，谁能解释我做错了什么？

Answer 1

诀窍是强制可变参数模板使由单个（对可选 const-qualified 的可选引用）参数组成的参数包的重载解析失败。

这是通过从参数包中的每个类型中删除引用和 const-qualifiers，从中组装一个元组，然后使用 std::is_same 来完成的，就像您尝试的那样，比较结果输入 std::tuple<T_Event>，然后在这种情况下通过否定类型特征来使重载解析失败（它不是 std::tuple<T_Event>.

#include <type_traits>
#include <tuple>
#include <iostream>

template <typename T_Event>
class EventHandler
{
public:

    template <typename... T_Args,
          typename=std::enable_if_t
          <std::negation<std::is_same
                 <std::tuple<std::remove_const_t
                         <std::remove_reference_t
                          <T_Args>>...>,
                          std::tuple<T_Event>>
                              >::value>>
    void emit(T_Args&&... args)
    {
        std::cout << "Variadic" << std::endl;
    }

    void emit(const T_Event& event)
    {
        std::cout << "Reference" << std::endl;
    }
};

int main()
{
    EventHandler<const char *> foo;
    const char *bar="foobar";

    foo.emit(4);
    foo.emit(4, "bar");
    foo.emit(bar);
    return 0;
}

使用 g++ 和 -std=c++17 进行测试。通过重新实现一些缺失的类型特征，这在 C++11 和 C++14 中应该是可行的。最终结果：

$ g++ -o t -std=c++17 t.C
$ ./t
Variadic
Variadic
Reference

具有可变模板参数的成员函数的显式特化

Explicit specialization of member function with variadic template arguments

c++

templates

variadic-templates