0

我有一个模板类，它使用可变参数模板参数和递归继承来保存 n 个 T。这很像一个元组，所以我在这里命名它：

template<class T, size_t tupleSize>
class MyTuple : private MyTuple<T, tupleSize - 1> {
private:
    T t;
public:
    MyTuple(std::string name)
            : t(name),
              MyTuple<T, tupleSize - 1>(name) {}
};

template<class T>
class MyTuple<T, 0> {
public:
    MyTuple(std::string name) {}
};

我现在正在尝试创建一个 CompositeTuple 类，它允许将多个 MyTuple 对象串在一起。这旨在保存 MyTuple 对象的实例或对 MyTuple 对象的引用，其用法类似于：

struct A {
    A(std::string s) {}
};

int main() {
    MyTuple<A, 3> a("hello");

    CreateCompositeTuple(a, MyTuple<A, 1>("world"));

    return 0;
}

不幸的是，我当前的 CompositeTuple 实现达不到标准：

template<class ...T>
class CompositeTuple;

template<>
class CompositeTuple<> {
};

template<template<class T, size_t tupleSize> class TupleType, size_t tupleSize, class T, class ...TupleTypes>
class CompositeTuple<TupleType<T, tupleSize>, TupleTypes...>
        : private CompositeTuple<TupleTypes...> {
private:
    const TupleType<T, tupleSize> tuple;
public:
    CompositeTuple(TupleType<T, tupleSize> &&tuple, TupleTypes &&...tuples)
            : CompositeTuple<TupleTypes...>(tuples...),
              tuple(std::forward<TupleType<T, tupleSize>>(tuple)) {}
};



template<template<class T, size_t tupleSize> class ...TupleType, size_t ...tupleSize, class ...T>
auto CreateCompositeTuple(TupleType<T, tupleSize> &&...tuples) {
    return CompositeTuple<TupleType<T, tupleSize>...>(std::forward<TupleType<T, tupleSize>...>(tuples...));
}

CreateCompositeTuple 的调用会生成以下编译器错误：error: cannot bind 'MyTuple' lvalue to 'MyTuple&&'

我在这里做错了什么？尽管我无法解决问题，但显然，我所做的所有阅读都表明这应该是可能的。

编辑： 我需要在 CompositeTuple 中有更多方法可以访问 T 和 tupleSize 模板参数。像这样的东西：

template<size_t index, typename std::enable_if<index < tupleSize>::type * = nullptr>
constexpr const T &At() const {
    return tuple.At<index>();
}

编辑 2： 尝试按照 Igor 的建议添加模板化构造函数：

// ...
template<template<class T, size_t tupleSize> class TupleType, size_t tupleSize, class T, class ...TupleTypes>
class CompositeTuple<TupleType<T, tupleSize>, TupleTypes...>
        : private CompositeTuple<TupleTypes...> {
private:
    const TupleType<T, tupleSize> tuple;
public:        
    template<class TT, class ...TTs>
    CompositeTuple(TT &&tuple, TTs &&...tuples)
        : CompositeTuple<TTs...>(tuples...),
          tuple(std::forward<TT>(tuple)) {}
};

template<class ...TupleType>
auto CreateCompositeTuple(TupleType &&...tuples) {
    return CompositeTuple<TupleType...>(std::forward<TupleType>(tuples)...);
}
//...

我现在在 CreateCompositeTuple 函数中出现“不完整类型的无效使用”错误。

4

0 回答 0