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>();
      }
   };

我原以为这会认为在ObjectType的{{1}}子句中替换is_same会导致其中一个表达式失败，因此只留下一个有效的特化。但是，模糊的名称和重新定义错误证明我错了。

为什么我的推理不正确？我怎样才能正确派遣电话呢？

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

一个类似的包，它丢弃其参数并始终返回Result：

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

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

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>()的类型并返回ObjectType。然后就停止了。

如果找不到这样的类型，则无法编译。

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

Answer 2

如果你能使用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。

Answer 3

怎么样？

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的库存;请参阅以下内容＆＃34; p.s。＆＃34;）但我认为过于复杂。

p.s。：我的clang ++请求template之前的get();我的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()以确保ObjectType在GroupA和GroupB所构成的列表中（通过SFINAE）;

之类的东西

  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>();
     }

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

3 个答案: