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

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

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

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 类型B 和 ObjectType 类型列表的 r/l 值。列表的长度受模板递归限制(通常在 100 秒内(的限制。

如果可以使用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);
}   

这两个分支都需要可解析，但实际上只有获取的分支才会被实例化。

我为会议C++ 2015 编写了关于static_if的教程。了解它是如何工作的并编写自己的实现应该就足够了。

我也在这里写了一个实现。

这两种实现都基于此 CppCoreGuidelines 问题。

怎么样

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."(，但我认为过于复杂。

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