编译时间调度：以有效调用为条件

Question

给定以下代码：

template<typename GroupA, typename GroupB>
class JoinedObjectGroup
   : public _ObjectSpaceHolder<GroupA>
   , public _ObjectSpaceHolder<GroupB>
   {
   public:
      JoinedObjectGroup(GroupA &groupA, GroupB &groupB)
         : _ObjectSpaceHolder<GroupA>(groupA)
         , _ObjectSpaceHolder<GroupB>(groupB)
         {
         }

      template<typename ObjectType>
      ObjectType get()
         {
            // Dispatch to appropriate handler: only one of the following actually compiles as
            // either GroupA knows about ObjectType or GroupB, but not both. So:
            //
         // return static_cast<_ObjectSpaceHolder<GroupA> &>(*this).m_objectSpace.get<ObjectType>();
            //  or
            // return static_cast<_ObjectSpaceHolder<GroupB> &>(*this).m_objectSpace.get<ObjectType>();
         }
   };

在 get() 调用中，我想对适当的处理程序执行编译时分派。基本思想是 ObjectType 被 GroupA 或 GroupB 知道。我最初的方法如下：

template<typename ObjectType>
ObjectType get()
    {
    return Dispatch<ObjectType, GroupA, GroupB>::get(*this);
    }

与：

template<typename ObjectType, typename GroupA, typename GroupB, typename = void>
struct Dispatch;

template<typename ObjectType, typename GroupA, typename GroupB>
struct Dispatch<ObjectType, GroupA, GroupB, typename std::enable_if<std::is_same<ObjectType, decltype(std::declval<GroupA>().template get<ObjectType>())>::value>::type>
   {
   template<typename JoinedGroup>
   static
   ObjectType get(JoinedGroup &joinedGroup)
      {
      return static_cast<_ObjectSpaceHolder<GroupA> &>(joinedGroup).m_objectSpace.get<ObjectType>();
      }
   };

template<typename ObjectType, typename GroupA, typename GroupB>
struct Dispatch<ObjectType, GroupA, GroupB, typename std::enable_if<std::is_same<ObjectType, decltype(std::declval<GroupB>().template get<ObjectType>())>::value>::type>
   {
   template<typename JoinedGroup>
   static
      ObjectType get(JoinedGroup &joinedGroup)
      {
      return static_cast<_ObjectSpaceHolder<GroupB> &>(joinedGroup).m_objectSpace.get<ObjectType>();
      }
   };

我曾假设这会起作用，认为在 enable_if 的 is_same 子句中替换 ObjectType 会导致其中一个表达式失败，因此只留下一个有效的专业化。但是，不明确的名称和重新定义错误证明我错了。

为什么我的推理不正确？我怎样才能正确地发送呼叫？

Answer 1

那

呢

template<typename ObjectType, typename GroupA, typename GroupB>
struct Dispatch;

template<typename GroupA, typename GroupB>
struct Dispatch<GroupA, GroupA, GroupB>
   {
   template<typename JoinedGroup>
   static
   GroupA get(JoinedGroup &joinedGroup)
      {
      return static_cast<_ObjectSpaceHolder<GroupA> &>(joinedGroup).m_objectSpace.template get<GroupA>();
      }
   };

template<typename GroupA, typename GroupB>
struct Dispatch<GroupB, GroupA, GroupB>
   {
   template<typename JoinedGroup>
   static
      GroupB get(JoinedGroup &joinedGroup)
      {
      return static_cast<_ObjectSpaceHolder<GroupB> &>(joinedGroup).m_objectSpace.template get<GroupB>();
      }
   };

?

你的假设对我来说似乎是正确的，我编译了你的代码（添加了一些 template；见下文 "p.s."）但我认为过于复杂。

p.s.: get() 之前的 template 是我的 clang++ 请求的；我的 g++ 不需要它但接受它。我想你也应该把它添加到你的版本中。

p.s.2：抱歉我的英语不好。

--- 编辑 ---

再想想，我的解决方案也太复杂了。

更简单的怎么样

  template<typename ObjectType>
  ObjectType get()
     {
       return static_cast<_ObjectSpaceHolder<ObjectType> &>(*this).m_objectSpace.template get<ObjectType>();
     }

?

如果您打算确保 ObjectType 是 GroupA 或 GroupB（以及其他类型，如果您不想将解决方案扩展到其他类型），您可以写一些这样的东西说一个类型是否在可变列表中；像

template <typename T0>
constexpr bool typeIsInList ()
 { return false; }

template <typename T0, typename T1, typename ... Tl>
constexpr bool typeIsInList ()
 { return std::is_same<T0, T1>::value || typeIsInList<T0, Tl...>(); }

并重新定义 get() 以确保（通过 SFINAE）ObjectType 在由 GroupA 和 GroupB 构成的列表中；像

  template<typename ObjectType, typename = typename std::enable_if<typeIsInList<ObjectType, GroupA, GroupB>()>::type>
  ObjectType get()
     {
       return static_cast<_ObjectSpaceHolder<ObjectType> &>(*this).m_objectSpace.template get<ObjectType>();
     }

Answer 2

namespace details {
  template<template<class...>class Z, class always_void, class...Ts>
  struct can_apply : std::false_type {};
  template<template<class...>class Z, class...Ts>
  struct can_apply<Z, std::void_t<Z<Ts...>>, Ts...> : std::true_type {};
}
template<template<class...>class Z, class...Ts>
using can_apply = details::can_apply<Z, void, Ts...>;

这需要一个模板和一个参数列表，并告诉您是否可以应用它们。

评估foo.get<Bar>()的模板：

template<class ObjectType, class Source>
using get_template_result = decltype( std::declval<Source>().get<ObjectType>() );

我们可以有效地调用上面的模板吗？

template<class ObjectType, class Source>
using can_get_template = can_apply< get_template_result, ObjectType, Source >;

将模板放入类型的包，让我们对其进行评估：

template<template<class...>class Z>
struct z_template {
  template<class...Ts>
  using result = Z<Ts...>;
};

一个类似的包，丢弃它的参数和 returns 结果总是：

template<class Result>
struct z_identity {
  template<class...>using result=Result;
};

如果可能，评估get_template_result。如果是，则将其类型与 ObjectType 进行比较。否则，将 ObjectType* 与 ObjectType 进行比较（保证为假）：

template<class ObjectType, class Source>
using get_template_gets_type = std::is_same<ObjectType,
  typename // maybe?
  std::conditional_t<
    can_get_template<ObjectType,Source>,
    z_template<get_template_result>,
    z_identity<ObjectType*>
  >::template result<ObjectType, Source>
>;

一旦我们有了所有这些，我们就可以标记调度了！

template<class ObjectType, class T0, class...Ts, class Source>
ObjectType get_smart( Source&& source, std::true_type ) {
  return static_cast<T0&&>(std::forward<Source>(source)).get<ObjectType>();
}
template<class ObjectType, class T0, class T1, class...Ts, class Source>
ObjectType get_smart( Source&& source, std::false_type ) {
  return get_smart<ObjectType, T1, Ts...>(std::forward<Source>(source), get_template_gets_type<ObjectType, T1>{} );
}
template<class ObjectType, class T0, class...Ts, class Source>
ObjectType get_smart( Source&& source ) {
  return get_smart( std::forward<Source>(source), get_template_gets_type<ObjectType, T0>{} );
}

现在 get_smart<ObjectType, TypeA, TypeB>( something ) 将搜索列表 TypeA 然后 TypeB 直到找到可以调用 .get<ObjectType>() 和 returns [=19= 的类型].然后它停止了。

如果没有找到这样的类型，则编译失败。

您负责设置 TypeA TypeB 和 ObjectType 类型列表的 r/l 值。列表的长度受模板递归限制的限制（通常在 100s 以内）。

Answer 3

如果可以使用 C++14，static_if 看起来是一个干净的解决方案：

template<typename ObjectType>
auto get()
{
    using is_group_a = std::is_same
    <
        ObjectType, 
        decltype(std::declval<GroupA>().template get<ObjectType>())
    >;

    return static_if(is_group_a{})
        .then([](auto& x_this)
        {
            return static_cast<_ObjectSpaceHolder<GroupA> &>(x_this)
                .m_objectSpace.get<ObjectType>();
        })
        .else_([](auto& x_this)
        {
            return static_cast<_ObjectSpaceHolder<GroupB> &>(x_this)
                .m_objectSpace.get<ObjectType>();           
        })(*this);
}

两个分支都需要可解析，但实际上只有被采用的分支会被实例化。

我已经为 Meeting C++ 2015 编写了 a tutorial on static_if。了解它的工作原理并编写您自己的实现应该就足够了。

我也写了an implementation here。

两种实现均基于this CppCoreGuidelines issue。

编译时间调度：以有效调用为条件

Compile time dispatch: conditional on valid call

c++

sfinae

c++11