c++ - Variadic 模板双端包解决方法

Question

以下代码可以编译，因为我假设 parent的 Object<Parent, T, Rest...>本身没有 parent 。

template <typename Parent, typename T, typename... Rest>
struct Object {
    T item;  // T is item's type, while Parent is parent's item's type.
    Object<T, Rest...>* child;  // child's item type is the first type from Rest...
    Object<void, Parent, T, Rest...>* parent;
    Object(const T& t) : item(t) {}
    void setChild (Object<T, Rest...>* c) {
        child = c;
        child->setParent(this);
    }
    void setParent (Object<void, Parent, T, Rest...>* p) {parent = p;}
};

template <typename Parent, typename T>
struct Object<Parent, T> {  // Has no child.
    T item;
    Object<void, Parent, T>* parent;
    Object(const T& t) : item(t) {}
    void setParent (Object<void, Parent, T>* p) {parent = p;}
};

template <typename... Args>
using ObjectWithNoParent = Object<void, Args...>;

int main() {
    ObjectWithNoParent<int, char, double> object(2);
    Object<int, char, double> child('r');
    object.setChild(&child);
    Object<char, double> grandChild(3.5);
//    child.setChild(&grandChild);  // Want this line to work.
}

我可以使用什么解决方法来替换类型 void与一般类型？

Answer 1

编译器必须能够分辨出一个参数包从哪里开始，另一个参数包从哪里结束。为此，您所要求的直接是不可能的，但有一个解决方法:使用另一个可变参数模板作为“包分隔符”。

我们的目标是支持这样的类型:

Object<pack<A, B>, C, pack<D, E>> foo;

在这种情况下，C是foo的值类型，它将具有以下相关类型:

Object<pack<A>, B, pack<C, D, E>> foo_parent;
Object<pack<A, B, C>, D, pack<E>> foo_child;

无父类型的第一包是空的，无子类型的第二包是空的。

由于您不能通过可变参数“向后递归”，所以这很复杂，因此具有父级的类型会有点混淆。 (不幸的是，template <typename... Types, typename Last> struct foo 方法不起作用，因为参数包必须是模板参数列表中的最后。)我们需要更多的助手来获取并“剥离”可变参数包中的最后一个类型(将 pack<A, B, C> 更改为 pack<A, B> )。

我们将从声明 pack 开始:

// Helper template; needs no definition since we never instantiate it.
template <typename...> struct pack;

现在我们需要一个助手来获取包中的最后一个类型；给出pack<A, B, C>它应该让我们获得C .为此，我们定义了一个元函数，该函数将从包的开头删除类型，直到只剩下一个。

// Helper to allow us to obtain the last type from a pack.
template <typename> struct last_type_in_pack;

template <typename T>
struct last_type_in_pack<pack<T>>
{
    typedef T type;
};

template <typename First, typename... Types>
struct last_type_in_pack<pack<First, Types...>>
    : public last_type_in_pack<pack<Types...>> { };

现在我们需要助手来转 pack<A, B, C>进入pack<A, B> .我们将在为对象构建父类型时使用它。这个元函数从模板参数开始工作 pack<>, pack<A, B, C>并将最左侧的右侧包移动到左侧包中最右侧的位置。当最右边的包还剩下一种类型时，最左边的包就是我们的最终类型。

如果这很难遵循，请执行以下步骤:

1. 从 pack<>, pack<A, B, C> 开始.正确的包有不止一个元素，所以我们继续。
2. 现在我们有 pack<A>, pack<B, C> .正确的包装仍然有不止一种元素。
3. 现在我们有 pack<A, B>, pack<C> .右边的包有一个元素，所以左边的包是我们的最终类型。

实现:

// We need another helper to allow us to "peel off" the last type from a pack,
// turning pack<A, B, C> into pack<A, B> for example.
template <typename, typename> struct remove_last_type_from_pack_impl;

template <typename... Types, typename LastType>
struct remove_last_type_from_pack_impl<pack<Types...>, pack<LastType>>
{
    typedef pack<Types...> type;
};

template <typename... TS1, typename T2, typename... TS2>
struct remove_last_type_from_pack_impl<pack<TS1...>, pack<T2, TS2...>>
    : public remove_last_type_from_pack_impl<pack<TS1..., T2>, pack<TS2...>> { };

template <typename>
struct remove_last_type_from_pack;

template <typename... Types>
struct remove_last_type_from_pack<pack<Types...>>
    : public remove_last_type_from_pack_impl<pack<>, pack<Types...>> { };

现在我们实际申报Object .我们没有定义它，因为我们将为每个预期的实例化提供部分特化。如果有人试图将此模板与我们不支持的参数一起使用，他们只会收到“不完整类型”错误，这正是我们想要的。

template <typename...> struct Object;

部分特化允许“双端”包，并且需要至少一种父类型和一种子类型。 (FirstParent 的存在只是为了强制当第一个包为空时此部分特化将不匹配。)

template <typename FirstParent, typename... ParentTypes,
          typename T,
          typename FirstChild, typename... ChildTypes>
struct Object<pack<FirstParent, ParentTypes...>, T, pack<FirstChild, ChildTypes...>>
{
    // We'll shift the packs around T to define our child and parent types:
    typedef Object<pack<FirstParent, ParentTypes..., T>,
                   FirstChild,
                   pack<ChildTypes...>> child_type;

    typedef Object<
        typename remove_last_type_from_pack<pack<FirstParent, ParentTypes...>>::type,
        typename last_type_in_pack<pack<FirstParent, ParentTypes...>>::type,
        pack<T, FirstChild, ChildTypes...>> parent_type;

    T item;
    child_type * child;
    parent_type * parent;

    Object(T const & t) : item(t) { }
    Object(T && t) : item(std::move(t)) { }
};

现在我们需要针对无 parent 和无子女的特化。

parent-less类型比较简单:

template <typename T, typename FirstChild, typename... ChildTypes>
struct Object<pack<>, T, pack<FirstChild, ChildTypes...>>
{
    typedef Object<pack<T>, FirstChild, pack<ChildTypes...>> child_type;

    T item;
    child_type * child;

    Object(T const & t) : item(t) { }
    Object(T && t) : item(std::move(t)) { }
};

现在是无子类型。和以前一样，FirstParent只是确保我们至少有一个父类型。

我们必须进行相同的操作才能获得父类型。

template <typename FirstParent, typename... ParentTypes, typename T>
struct Object<pack<FirstParent, ParentTypes...>, T, pack<>>
{
    typedef Object<
        typename remove_last_type_from_pack<pack<FirstParent, ParentTypes...>>::type,
        typename last_type_in_pack<pack<FirstParent, ParentTypes...>>::type,
        pack<T>> parent_type;

    T item;
    parent_type * parent;

    Object(T const & t) : item(t) { }
    Object(T && t) : item(std::move(t)) { }
};

注意此时Object<pack<>, T, pack<>>无法实例化，因为没有与之匹配的特化，并且未定义基本模板。这种类型并没有多大意义，IMO，但你可以专门化 Object如果你愿意的话:

template <typename T>
struct Object<pack<>, T, pack<>>
{
    T item;

    Object(T const & t) : item(t) { }
    Object(T && t) : item(std::move(t)) { }
};

如果你还想要你的 ObjectWithNoParent模板别名，这是现在的样子:

template <typename Arg, typename... Rest>
using ObjectWithNoParent = Object<pack<>, Arg, pack<Rest...>>;

(Here is a sample 并没有做太多，但它确实表明它可以编译并断言父类型和子类型是我们所期望的。)