stdtuple

I want to make a template where I can input an index and it will give me the type at that index. I know I can do this with decltype(std::get<N>(tup)) but I would like to implement this myself. For example, I would like to do this, typename get<N, std::tuple<int, bool, std::string>>::type; ...and it will give me the type at position N - 1 (because arrays indexed starting from 0). How can I do this? Thanks. You can use a class template and partial specializations to do what you want. (Note that std::tuple_element does almost the same like the other answer says): #include <tuple> #include <type

I want to use a triplet class, as similar as possible to std::pair. STL doesn't seem to have one. I don't want to use something too heavy, like Boost. Is there some useful FOSS non-restrictive-license triplet class I could lift from somewhere? Should I roll my own? Should I do something else entirely? Edit: About std::tuple ... Is there really no benefit to a triplet-specific class? I mean, with tuple, I can't do template<typename T1, typename T2, typename T3> std::tuple<T1, T2, T3> triple; now can I? Won't I have to typedef individual-type-combination triples? Joseph Mansfield No, don't roll

In reading this summary of the c++17 final features I was a bit surprised by the section on structured bindings (emphasis mine): structured bindings Until now, there was a known trick to abuse std::tie to assign a tuple or pair to different variables directly, instead of having to deal with the result type manually. This was a hack , and also the variables had to exist, now you can declare the variables and initialize them in one line: auto [a , b , c] = getvalues(); The braces are needed, getvalues returns a tuple. std::pair is not mentioned in the proposal, so its unclear if this works with

Let's say I have std::tuple<T0, T1, T2> my_tuple{x0, x1, x2}; where T0 , T1 and T2 are value types (i.e. no aliasing is possible) . Is it safe to access my_tuple 's elements and mutate them concurrently from multiple threads using std::get , as long as every thread accesses a different element? Example: template <typename T> void process(T& x) { /* mutate `x` */ } // ... std::thread{[&]{ process(std::get<0>(my_tuple)); }}.detach(); std::thread{[&]{ process(std::get<1>(my_tuple)); }}.detach(); std::thread{[&]{ process(std::get<2>(my_tuple)); }}.detach(); Instinctively I would say it is safe, as

I have function at designed to access std::tuple element by index specified in runtime template<std::size_t _Index = 0, typename _Tuple, typename _Function> inline typename std::enable_if<_Index == std::tuple_size<_Tuple>::value, void>::type for_each(_Tuple &, _Function) {} template<std::size_t _Index = 0, typename _Tuple, typename _Function> inline typename std::enable_if < _Index < std::tuple_size<_Tuple>::value, void>::type for_each(_Tuple &t, _Function f) { f(std::get<_Index>(t)); for_each<_Index + 1, _Tuple, _Function>(t, f); } namespace detail { namespace at { template < typename