C++ 我可以检测在编译时使用了哪个标记分派重载吗？

假设我有一个functor，它使用标记分派从函数的多个实现中进行选择，如下所示：

// base class for all tags, indicating the "default" implementation
struct tag_base { };

// subclasses for tags that might select a different implementation
struct tag1 : tag_base { };
struct tag2 : tag1  { };
struct tag3 : tag2 { };

struct func
{
    void operator()(tag_base) { }
    void operator()(tag3) { }
};

因此，在这个简单的示例中，标记类型tag1和tag2将分派给func的call运算符，该运算符采用默认实现tag_基。然而，tag3将被分派到不同的实现。我感兴趣的是在编译时检查，对于给定的函数类型func和两个标记类型T和U，它们是否会分派给func的调用运算符的相同重载

基本上，我只需要伪代码，因为这种方法不编译：

template <typename Func, typename T, typename U>
struct has_same_tag_overload
{
    enum { value =  (void (Func::*)(T)) &func::operator() ==
                    (void (Func::*)(U)) &func::operator() };
}

因此，在上述示例中，以下是正确的：

标记：：值==1 标记：：值==1 标记：：值==1 标记：：值==0 标记：：值==0

---

这可能吗？更难的是，这在C++03中可能吗？

我能想到的最简单的方法是，这样做会使func类型的定义严重复杂化。我将在这里使用C++14功能：

#include <type_traits>

template <typename Func, typename Tag1, typename Tag2>
using has_same_tag_overload =
    std::is_same<decltype(Func::fn(Tag1{})), decltype(Func::fn(Tag2{}))>;

struct func
{
    static auto fn(tag_base) {
        return [] { std::cout << "tag_base\n"; };
    }
    static auto fn(tag3) {
        return [] { std::cout << "tag3\n"; };
    }

    template <typename Tag>
    void operator()(Tag tag)
    {
        fn(tag)();
    }
};

其思想是让func结构在调用函数之前创建要调用的函数，使每个函数都是不同的类型。这意味着我们可以简单地使用std:：is_same比较函数类型

---

这在C++03中是可行的，但是代码变得更加混乱。func必须返回不同的函数对象类型。您可以使用sizeof技巧，而不是decltype，让func中的每个函数对象类型具有不同的大小，这样您就可以比较大小。

如果标记形成树层次结构，因此可以编写为

struct tag_base { using base = void; };
struct tag1 : tag_base { using base = tag_base; };
struct tag2 : tag1  { using base = tag1; };
struct tag3 : tag1  { using base = tag1; };
...
// or something like tag4: is_a<tag2> {}; if you don't like typing ...

然后我们就可以写了

template<class U>
struct tag_matcher
{
  template<class V, class W = std::enable_if_t<std::is_same<U,V>::value> >
  operator V();
};

template<typename F, typename T>
std::true_type match_tag_impl( decltype(F{}(tag_matcher<T>()))* );

template<typename F, typename T>
std::false_type match_tag_impl( ... );

template<typename F, typename T>
struct match_tag
{
  using type = std::conditional_t< decltype(match_tag_impl<F,T>(0))::value,
    T, typename match_tag<F, typename T::base>::type >;
};

template<typename F>
struct match_tag<F,void> { using type = void; };

template<typename F, typename T, typename U>
struct has_same_tag_overload:
  std::is_same< typename match_tag<F,T>::type, typename match_tag<F,U>::type > {};

其思想是检查所有祖先以找到最派生的匹配，然后检查两者是否相同。这是c++11，但据我所知，你也可以让它在c++03上工作

更新re C++03: 如注释中所述，上面定义的标记匹配器无法在c++03中工作，因为我们没有默认的函数模板参数，因此无法使用支持sfinae的转换运算符模板。 也就是说，我们可以移动与标记转换构造函数相同的逻辑：

template<class U>
struct tag_matcher{};

// macro just for expository purposes
#define MATCHME(TAG) template<class T> TAG( tag_matcher<T>, std::enable_if_t<std::is_same<T,TAG>::value>* = 0 )

struct tag_base { using base = void; MATCHME(tag_base); };
struct tag1 : tag_base { using base = tag_base; MATCHME(tag1); };
// ...

---

@不，没有，原因有二：1。无法比较不同类型的指针是否相等，以及2。没有void func:：*tag1类型的重载，因此该特征不适用于继承。很抱歉，我将其转移到这里时输入错误。gcc抱怨演员阵容无效；我想使用T=tag1和U=tag2调用trait，但由于相应的重载使用tag_base，它表示转换无效。@JasonR函数实际上是无效的，还是简化了？如果将返回类型更改为与标记参数相同，我希望您可以这样做，但即使在C++11中，我也只知道如何使用decltype。@VTT我相信检查应该都能工作，除了我使用static_assert编写检查的部分。检查重载是否存在只是其中的一部分，如果没有相关的重载，我们可以假设并拒绝编译。@DanielH：函数不是空的，这是一种简化，但两个不同标记的返回类型在某些情况下是相同的。是的，我想到了一些类似的东西，但不幸的是，回归虚空只是一种简化。我想您可以这样做，但可以向实际返回类型添加隐式转换。@DanielH使用此技术处理返回类型非常简单：在lambda和运算符上添加返回类型这是一个好主意。我想我也许能做到这一点；我没有考虑在标记类型本身中构建任何额外的元数据。我也没有看到任何会妨碍C++03实现的东西。谢谢嗯，在看了更多之后，我一直在把tag\u matcher转换操作符上的std:：enable\u if\t翻译成C++03。函数上的默认模板参数在C++11之前不受支持，因此通过SFINAE禁用转换运算符。你有没有看到任何其他的解决方案？@jasonr你说得对，错过了。您是否尝试过添加一个等效的标记匹配器，将构造函数转换为标记？@jasonr好的，现在我自己进行了测试，它对我有效，请参见编辑