c++ - 编译时分派(dispatch) : conditional on valid call

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() 调用中，我想对适当的处理程序执行编译时分派(dispatch)。基本思想是 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

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...>;
};

一个类似的包，丢弃它的参数并总是返回结果:

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>
>;

一旦我们拥有所有这些，我们就可以标记 dispatch 了!

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>()返回 ObjectType .然后它停止了。

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

您负责设置 TypeA TypeB 和 ObjectType 列表的 r/l value-ness .列表的长度受模板递归限制的限制(通常在 100s 以内)。