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

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

我有一个“emit”成员函数，它将根据提供的可变模板参数构造一个事件对象并转发事件。但是，我想提供一个专门的“emit”函数，该函数将检测所提供的参数是否是预先构造的事件对象，在这种情况下，我可以转发事件，而无需进行多余的复制

我最初的尝试

模板
类事件处理程序
{
公众：
模板
无效发射（T_参数&…参数）
{
printf（“可变变量”）；
交付（T_事件{std:：forward（args）…}）；
}
无效发射（常数T_事件和事件）
{
printf（“参考文件”）；
交付（事件）；
}
...
};

我使用了下面的逻辑来尝试这两个emit函数，但事实证明可变模板函数总是优先于常量引用函数

struct Event { int x; };

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

struct事件{intx；}；
事件处理程序；
事件{1}；
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)...);
  }

模板
无效发射（T_参数&…参数）
{
printf（“可变变量”）；
事件{std:：forward（args）…}；
交付（事件）；
}
模板
无效发射（T_参数&…参数）
{
printf（“参考文件”）；
交付（标准：转发（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 &>, $1 =
  std::__1::enable_if<false, void>]
void emit(T_Args&&... args)

对成员函数“emit”的调用不明确
emit（事件）；
候选函数[带T_参数=]
无效发射（T_参数&…参数）
候选函数[带T_参数=，$1=
std:：_1:：启用_if]
无效发射（T_参数&…参数）

---

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

诀窍是强制可变模板对包含单个（可选引用一个可选常量限定）参数的参数包进行重载解析失败

这是通过从参数包中的每个类型中删除引用和常量限定符来完成的，将它们组合成一个元组，并使用

std:：is_same

，就像在尝试中一样，将结果类型与

std:：tuple

进行比较，然后通过否定类型特征来失败重载解析（它不是一个

std:：tuple

---

正确的方法是使用

const T_Event&

和

T_Event&

。问题是在调用emit函数之前仍然需要构造T_Event&&而不是向emit函数提供原始事件构造函数参数。

invoke

是否意味着

std:：invoke

？不，这是另一种情况我将在示例中重命名它以避免混淆。非常感谢您，先生！

#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++ -o t -std=c++17 t.C
$ ./t
Variadic
Variadic
Reference