index_sequence 用法 class

Question

我想创建一个 class 将采用以下输入：

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

并且在 class 中有一个静态类型的元组：

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

和内容：

{1,'A',2,'B'}

应该创建。

有点像这样-但不是返回元组的函数-它应该是一个元组，它是 class:

的成员变量

http://ideone.com/iu1wm5

我知道我手动声明了元组 - 但我打算在弄清楚如何执行此操作后修复它。

我还没有找到任何索引和模板的示例 classes- 如果您有 link 这样的示例，那也很棒。

我知道 http://cpptruths.blogspot.dk/2012/06/perfect-forwarding-of-parameter-groups.html 但他使用的是向量而不是元组。

Answer 1

是这样的吗？

#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;
}

Answer 2

I want to create a class that will take the following input:

你不需要为这样的东西创建一个class。我不确定你为什么想要一个只有一个成员是 tuple 的 class，这似乎不如只有一个 tuple 有用。这是一个通用的解决方案：

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

基本上，tuple_combiner 接受任意数量的参数，这些参数可以是也可以不是 tuple。我们在参数的包装版本上调用 tuple_cat() - tuple 的参数被转发，而没有被包装在 tuple 中的参数首先被转发。我们还转发所有内容以尽量减少副本：

index_sequence 用法 class

index_sequence usage for a class

c++

templates

c++14

template-meta-programming