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

Question

假设我有一个仿函数，它使用从函数的多个实现中分派到 select 的标签，像这样：

// 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 的调用运算符，该运算符采用默认实现 tag_base。但是，tag3 会分派到不同的实现。我有兴趣在编译时检查，对于给定的函数类型 func 和两个标记类型 T 和 U，它们是否会分派到 [=14= 的相同重载] 的呼叫操作员。

基本上，我想要这样的特征（只有伪代码，因为这种方法无法编译）：

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

因此在上面的示例中，以下内容为真：

tag<func, tag_base, tag1>::value == 1
tag<func, tag_base, tag2>::value == 1
tag<func, tag1, tag2>::value == 1
tag<func, tag1, tag3>::value == 0
tag<func, tag2, tag3>::value == 0

这可能吗？增加难度，这在C++03中可行吗？

Answer 1

我能想到的最简单的方法会使 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 必须 return 不同的函数对象类型。除了 decltype，您还可以使用 sizeof 技巧（让 func 中的每个函数对象类型具有不同的大小，以便您可以比较大小。

Answer 2

如果标签形成树状层次结构，则可以写成

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 上工作。

更新 C++03：

如评论中所述，上面定义的 tag_matcher 在 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); };
// ...

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

Can I detect which tag dispatch overload is used at compile time?

c++

metaprogramming

c++03

更新 C++03：