Question

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

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) {}
};

我现在正在尝试创建一个允许多个MyTuple对象串在一起的CompositeTuple类。这是为了保存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)...);
}
//...

我现在有一个＆＃34;无效使用不完整类型＆＃34; CreateCompositeTuple函数中的错误。

无法将l值绑定到fowarding reference

0 个答案: