C++ 类的索引\u序列用法

我想创建一个将接受以下输入的类：

1,make_tuple('A',2,'B')

在静态类型的类a元组中：

std::tuple<int,char,int,char>

应该创建

有点像这样-但不是返回元组的函数-它应该是作为类的成员变量的元组：

我知道我是手动声明元组的——但我打算在弄清楚如何做之后修复它

我还没有找到任何标记和模板类的例子——如果你有这样一个例子的链接，那也太好了

我知道，但他使用的是向量，而不是元组。

类似的东西

#include <iostream>
#include <string>
#include <tuple>
#include <typeinfo>
#include <cstddef>

template<class Ch, class Tr, class Tuple, std::size_t... Is>
void print_tuple_impl(std::basic_ostream<Ch, Tr>& os,
                      const Tuple & t,
                      std::index_sequence<Is...>)
{
    using swallow = int[]; // guaranties left to right order
    (void)swallow {
        0, (void(os << (Is == 0 ? "" : ", ") << std::get<Is>(t)), 0)...
    };
}

template<class Ch, class Tr, class... Args>
auto operator<<(std::basic_ostream<Ch, Tr>& os, const std::tuple<Args...>& t)
-> std::basic_ostream<Ch, Tr>&
{
    os << "(";
    print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
    return os << ")";

}

template<class Tuple>
struct X {
    void print() const {
        std::cout << _tuple << std::endl;
    }
    Tuple _tuple;
};

template<class First, class...Rest>
struct myClass
{
    std::tuple<First, Rest...> myTuple;

    myClass(First parameterOne, std::tuple<Rest...> param2)
    : myTuple(std::tuple_cat(std::make_tuple(parameterOne),
                             param2))
    {

    }

    void print() const {
        std::cout << myTuple << std::endl;
    }
};

template<class First, class...Rest>
auto make_myClass(const First& f, const std::tuple<Rest...> rest)
-> myClass<First, Rest...>
{
    return { f, rest };
}

using namespace std;

int main()
{
    auto mine = make_myClass(1, make_tuple('a', 4));
    mine.print();

    return 0;
}

#包括
#包括
#包括
#包括
#包括
模板
无效打印组（标准：：基本组和操作系统），
常量元组&t，
std:：索引（U序列）
{
使用swallow=int[]；//保证从左到右的顺序
（无效）吞咽{
0，（无效）操作系统
我想创建一个将接受以下输入的类：

1,make_tuple('A',2,'B')

你不需要为这样的事情创建类。我不知道你为什么想要一个只有
元组成员的类，这似乎比只有
元组有用。下面是一个通用的解决方案：

namespace details {
    template <typename T>
    struct is_tuple : std::false_type { };

    template <typename... Args>
    struct is_tuple<std::tuple<Args...>> : std::true_type { };

    // not a tuple? wrap it with std::make_tuple()
    template <typename T,
              std::enable_if_t<!is_tuple<std::decay_t<T>>::value>* = nullptr>
    auto as_tuple(T&& t) { return std::make_tuple(std::forward<T>(t));  }

    // is a tuple? 
    template <typename T,
              std::enable_if_t<is_tuple<std::decay_t<T>>::value>* = nullptr>
    decltype(auto) as_tuple(T&& t) { return std::forward<T>(t); }
}

template <typename... Args>
auto tuple_combiner(Args&&... args) {
    return std::tuple_cat(details::as_tuple(std::forward<Args>(args))...);
}

名称空间详细信息{
模板
结构是_元组：std:：false_type{}；
模板
结构是_元组：std:：true_type{}；
//不是一个元组？用std:：make_tuple（）包装它
模板：：值>*=nullptr>
自动作为元组（T&&T）{return std:：make_tuple（std:：forward（T））；}
//是元组吗？
模板
decltype（auto）as_tuple（T&&T）{return std:：forward（T）；}
}
模板
自动元组组合器（Args&&…Args）{
返回std：：tuple_cat（细节：：as_tuple（std：：forward（args））…）；
}

基本上，
tuple\u combiner
接受任意数量的参数，这些参数要么是，要么不是
tuple
s。我们称之为
tuple\u cat（）
在参数的包装版本上-属于
元组的参数首先被转发，而不属于
元组的参数首先被转发。我们还转发所有内容以最小化副本：
@Hansveselgård应答更新以反映（可能超过）需求。