我希望能够做到这一点:

template<typename Mix>
struct A {
  A(int i) { }
};

template<typename Mix>
struct B {
  B() { }
  B(const char*) { }
};

template<template<typename> class... Mixins>
struct Mix : Mixins<Mix<Mixins...>>... {
   // This works, but forces constructors to take tuples
   template<typename... Packs>
   Mix(Packs... packs) : Packs::Type(packs.constructorArgs)... { }
};

template<template<typename> class MixinType, typename... Args>
struct ArgPack {
  typedef MixinType Type; // pretend this is actually a template alias
  tuple<Args...> constructorArgs;
  ArgPack(Args... args) : constructorArgs(args...) { }
}

template<typename... Args>
ArgPack<A, Args...> A_(Args... args) {
  return ArgPack<A, Args...>(args...);
}

template<typename... Args>
ArgPack<B, Args...> B_(Args... args) {
  return ArgPack<B, Args...>(args...);
}

Mix<A, B> m(); // error, A has no default constructor

Mix<A, B> n(A_(1)); // A(int), B()
Mix<A, B> n(A_(1), B_("hello"); // A(int), B(const char*)

我如何填写/* 神秘的代码 */来做我想做的事，为调用一些 mixin 的构造函数集提供一个漂亮的接口(interface)？我有一个解决方案，它的工作原理是让所有非 null 构造实际上采用一个 args 元组，然后重载找出要调用的那个，但我想通过让他们编写构造函数 A(元组)来避免限制 mixin 作者，而不仅仅是 A(int, int)。

谢谢!

最佳答案

我想我明白你想要什么。 std::pair具有相似的特点:

std::pair<T, U> p(std::piecewise_construct
                      , std::forward_as_tuple(foo, bar)
                      , std::forward_as_tuple(qux) );
// p.first constructed in-place as if first(foo, bar) were used
// p.second constructed in place as if second(qux) were used

如您所见，这有很多好处:只有一个 T和 U每个建筑都发生了，都没有T和 U必须是例如MoveConstructible，这只会花费两个浅元组的构造。这也做完美转发。不过作为警告，如果不继承构造函数，这将很难实现，我将使用该功能来演示分段构造函数的可能实现，然后尝试制作它的可变版本。

但首先，当涉及可变参数包和元组时，一个简洁的实用程序总是派上用场:

template<int... Indices>
struct indices {
    using next = indices<Indices..., sizeof...(Indices)>;
};

template<int Size>
struct build_indices {
    using type = typename build_indices<Size - 1>::type::next;
};
template<>
struct build_indices<0> {
    using type = indices<>;
}

template<typename Tuple>
constexpr
typename build_indices<
    // Normally I'd use RemoveReference+RemoveCv, not Decay
    std::tuple_size<typename std::decay<Tuple>::type>::value
>::type
make_indices()
{ return {}; }

所以现在如果我们有using tuple_type = std::tuple<int, long, double, double>;然后make_indices<tuple_type>()产生 indices<0, 1, 2, 3> 类型的值.

首先，分段构造的非可变情况:

template<typename T, typename U>
class pair {
public:
    // Front-end
    template<typename Ttuple, typename Utuple>
    pair(std::piecewise_construct_t, Ttuple&& ttuple, Utuple&& utuple)
        // Doesn't do any real work, but prepares the necessary information
        : pair(std::piecewise_construct
                   , std::forward<Ttuple>(ttuple), std::forward<Utuple>(utuple)
                   , make_indices<Ttuple>(), make_indices<Utuple>() )
     {}

private:
    T first;
    U second;

    // Back-end
    template<typename Ttuple, typename Utuple, int... Tindices, int... Uindices>
    pair(std::piecewise_construct_t
             , Ttuple&& ttuple, Utuple&& utuple
             , indices<Tindices...>, indices<Uindices...>)
        : first(std::get<Tindices>(std::forward<Ttuple>(ttuple))...)
        , second(std::get<Uindices>(std::forward<Utuple>(utuple))...)
    {}
};

让我们尝试用你的 mixin 插入它:

template<template<typename> class... Mixins>
struct Mix: Mixins<Mix<Mixins...>>... {
public:
    // Front-end
    template<typename... Tuples>
    Mix(std::piecewise_construct_t, Tuples&&... tuples)
        : Mix(typename build_indices<sizeof...(Tuples)>::type {}
                  , std::piecewise_construct
                  , std::forward_as_tuple(std::forward<Tuples>(tuples)...)
                  , std::make_tuple(make_indices<Tuples>()...) )
    {
        // Note: GCC rejects sizeof...(Mixins) but that can be 'fixed'
        // into e.g. sizeof...(Mixins<int>) even though I have a feeling
        // GCC is wrong here
        static_assert( sizeof...(Tuples) == sizeof...(Mixins)
                       , "Put helpful diagnostic here" );
    }

private:
    // Back-end
    template<
        typename TupleOfTuples
        , typename TupleOfIndices
        // Indices for the tuples and their respective indices
        , int... Indices
    >
    Mix(indices<Indices...>, std::piecewise_construct_t
            , TupleOfTuples&& tuple, TupleOfIndices const& indices)
        : Mixins<Mix<Mixins...>>(construct<Mixins<Mix<Mixins...>>>(
            std::get<Indices>(std::forward<TupleOfTuples>(tuple))
            , std::get<Indices>(indices) ))...
    {}

    template<typename T, typename Tuple, int... Indices>
    static
    T
    construct(Tuple&& tuple, indices<Indices...>)
    {
        using std::get;
        return T(get<Indices>(std::forward<Tuple>(tuple))...);
    }
};

如您所见，我已经将那些元组的元组和索引的元组提升了一个级别。原因是我无法表达和匹配 std::tuple<indices<Indices...>...> 之类的类型(相关包声明为什么？int...... Indices？)即使我做了包扩展，也不是为了过多地处理多级包扩展而设计的。您现在可能已经猜到了，但在解决此类问题时，我的惯用做法是将其全部打包在一个与其索引捆绑在一起的元组中……这确实有缺点，但是构造是不在了，Mixins<...>现在需要是 MoveConstructible。

我建议也添加默认构造函数(即 Mix() = default; )，因为使用 Mix<A, B> m(std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple());看起来很傻。请注意，如果 Mixin<...> 中的任何一个，这样的默认声明将不会产生默认构造函数。不是 DefaultConstructible。

该代码已经使用 GCC 4.7 的快照进行了测试，并且除了 sizeof...(Mixins) 之外都可以正常工作。不幸的事。

关于c++ - 如何根据标记的参数包调用一组可 rebase 类构造函数？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/9730593/