C++ 无法将l值绑定到正向引用

我有一个模板类，它使用可变模板参数和递归继承保存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) {}
};

编辑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)...);
}
//...

/。。。
模板
类复合偶
：private CompositeTuple{
私人：
常量元组类型元组；
公众：
模板
复合元组（TT&&tuple，TTs&&tuple）
：复合元组（元组…），
元组（std:：forward（tuple））{}
};
模板
自动创建复合元组（元组类型和…元组）{
返回复合元组（std:：forward（元组）…）；
}
//...

---

我现在在CreateCompositeTuple函数中遇到了一个“无效使用不完整类型”错误。

TupleType&&

是一个右值引用，而不是通用引用（

T&

将是通用引用）。当然，左值不能绑定到右值引用。因此，为了实现我在这里的目标，我必须引入一个包装CompositeTuple的模板类，然后将CompositeTuple专门用于引用/非引用值？您可以使用一个模板构造函数，通过通用引用采用任意类型，而不是特别地

TupleType

。@IgorTandetnik谢谢你，我能够做出你建议的更改并使我的初始示例正常工作，但是我编辑了这个问题，添加了这个CompositeTuple类的额外要求。我不确定我是否理解困难的性质

CompositeTuple

将

T

和

tupleSize

作为模板参数。在上的

到底有什么问题？
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...));
}

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

// ...
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)...);
}
//...