C++ 使用参数包的声明

Question

我想定义一个类，它继承自一堆类，但不隐藏这些类的某些特定方法。

想象一下下面的代码：

template<typename... Bases>
class SomeClass : public Bases...
{
public: 
  using Bases::DoSomething...;

  void DoSomething(){
    //this is just another overload
  }
};

现在的问题是，如果只有一个类没有名为 DoSomething 的成员，我会收到错误消息。 我已经尝试过使用宏和 SFINAE 模拟“忽略如果未定义使用”，但要处理所有情况，这变得非常大而且丑陋！ 你有什么办法解决这个问题吗？

如果我能定义：“嘿，使用 - 忽略缺失的成员”，那就太好了。

这里有一些示例代码：Godbolt

Answer 1

Jarod42's approach 的问题在于你改变了重载决议的样子——一旦你把所有东西都变成了模板，那么所有东西都是完全匹配的，你就不能再区分多个可行的候选者了：

struct A { void DoSomething(int); };
struct B { void DoSomething(double); };
SomeClass<A, B>().DoSomething(42); // error ambiguous

保留重载决议的唯一方法是使用继承。

这里的关键是完成ecatmur 开始的事情。但是HasDoSomething 看起来像什么？链接中的方法仅在存在单个非重载非模板时才有效。但我们可以做得更好。我们可以使用相同的机制来检测 DoSomething 是否存在，即需要以 using 开头的机制：来自不同范围的名称不会重载。

因此，我们引入了一个新的基类，它有一个永远不会被真正选择的DoSomething——我们通过创建我们自己的明确标签类型来做到这一点，我们是唯一会构建的标签类型。由于没有更好的名字，我将以我的狗命名，它是一只 Westie：

struct westie_tag { explicit westie_tag() = default; };
inline constexpr westie_tag westie{};
template <typename T> struct Fallback { void DoSomething(westie_tag, ...); };

为了更好地衡量它，让它成为可变参数，只是为了让它最少。但其实无所谓。现在，如果我们引入一个新类型，比如：

template <typename T> struct Hybrid : Fallback<T>, T { };

然后，当T 确实不 有DoSomething 重载时，我们可以在混合上调用DoSomething() - 任何类型。那是：

template <typename T, typename=void>
struct HasDoSomething : std::true_type { };
template <typename T>
struct HasDoSomething<T, std::void_t<decltype(std::declval<Hybrid<T>>().DoSomething(westie))>>
    : std::false_type
{ };

请注意，通常在这些特征中，主要特征是 false，而特化特征是 true - 这里反过来。这个答案和 ecatmur 的主要区别在于，回退的重载必须仍然可以以某种方式调用 - 并使用该功能来检查它 - 只是对于用户实际使用的任何类型，它实际上都不会被调用。

以这种方式检查可以让我们正确地检测到：

struct C {
    void DoSomething(int);
    void DoSomething(int, int);
};

确实满足HasDoSomething。

然后我们使用 ecatmur 展示的相同方法：

template <typename T>
using pick_base = std::conditional_t<
    HasDoSomething<T>::value,
    T,
    Fallback<T>>;

template<typename... Bases>
class SomeClass : public Fallback<Bases>..., public Bases...
{
public: 
  using pick_base<Bases>::DoSomething...;

  void DoSomething();
};

无论Bases 的DoSomething 重载是什么样的，这都能正常工作，并且在我提到的第一种情况下正确执行重载解析。

Demo

Answer 2

有条件地使用后备怎么样？

为每个方法创建不可调用的实现：

template<class>
struct Fallback {
    template<class..., class> void DoSomething();
};

为每个基类从Fallback 继承一次：

class SomeClass : private Fallback<Bases>..., public Bases...

然后有条件地从基类或其各自的后备中拉入每个方法：

using std::conditional_t<HasDoSomething<Bases>::value, Bases, Fallback<Bases>>::DoSomething...;

Example.

Answer 3

您可以添加通过转发而不是using 来处理基本案例的包装器：

template <typename T>
struct Wrapper : T
{
    template <typename ... Ts, typename Base = T>
    auto DoSomething(Ts&&... args) const
    -> decltype(Base::DoSomething(std::forward<Ts>(args)...))
    {
        return Base::DoSomething(std::forward<Ts>(args)...);
    }

    template <typename ... Ts, typename Base = T>
    auto DoSomething(Ts&&... args)
    -> decltype(Base::DoSomething(std::forward<Ts>(args)...))
    {
        return Base::DoSomething(std::forward<Ts>(args)...);
    }

    // You might fix missing noexcept specification
    // You might add missing combination volatile/reference/C-elipsis version.
    // And also special template versions with non deducible template parameter...
};

template <typename... Bases>
class SomeClass : public Wrapper<Bases>...
{
public: 
  using Wrapper<Bases>::DoSomething...; // All wrappers have those methods,
                                        // even if SFINAEd

  void DoSomething(){ /*..*/ }
};

Demo

正如 Barry 所指出的，随着重载分辨率的改变，还有其他缺点，使得一些调用模棱两可......

注意：我提出了这个解决方案，因为我不知道如何创建正确的特征来在所有情况下检测DoSomething 的存在（主要是重载问题）。 巴里解决了这个问题，所以你有更好的选择。

Answer 4

只要您愿意使用别名模板来命名您的类，您就可以在没有额外基类的情况下实现这一点。诀窍是根据谓词将模板参数分隔成两个包：

#include<type_traits>

template<class,class> struct cons;  // not defined
template<class ...TT> struct pack;  // not defined

namespace detail {
  template<template<class> class,class,class,class>
  struct sift;
  template<template<class> class P,class ...TT,class ...FF>
  struct sift<P,pack<>,pack<TT...>,pack<FF...>>
  {using type=cons<pack<TT...>,pack<FF...>>;};
  template<template<class> class P,class I,class ...II,
           class ...TT,class ...FF>
  struct sift<P,pack<I,II...>,pack<TT...>,pack<FF...>> :
    sift<P,pack<II...>,
         std::conditional_t<P<I>::value,pack<TT...,I>,pack<TT...>>,
         std::conditional_t<P<I>::value,pack<FF...>,pack<FF...,I>>> {};

  template<class,class=void> struct has_something : std::false_type {};
  template<class T>
  struct has_something<T,decltype(void(&T::DoSomething))> :
    std::true_type {};
}

template<template<class> class P,class ...TT>
using sift_t=typename detail::sift<P,pack<TT...>,pack<>,pack<>>::type;

然后分解结果并从各个类继承：

template<class> struct C;
template<class ...MM,class ...OO>  // have Method, Others
struct C<cons<pack<MM...>,pack<OO...>>> : MM...,OO... {
  using MM::DoSomething...;
  void DoSomething();
};

template<class T> using has_something=detail::has_something<T>;

template<class ...TT> using C_for=C<sift_t<has_something,TT...>>;

请注意，为简单起见，此处的 has_something 仅支持非重载方法（每个基类）；请参阅 Barry 对此的概括回答。