別のstdへのstd ::タプルをマッピング::タプル

Question

は私がstd::tuple<std::priority_queue<Types...>>

#include <queue> 
#include <tuple> 

template<typename TypesTuple> 
struct Bar { 
    std::priority_queue<std::for_each_tuple_type(TypesTuple)...> queues; 
}; 

using Foo = Bar<std::tuple<int, double>>; 

どのようにそれを達成することができる生成する、のは、私がstd::tuple<Types...>を持っていると仮定しましょうか？

EDIT

それはブースト::タプルまたはベクターを用いて簡単に取得し、変換してもらえますか？メタレベルで変換を適用できますか？

Answer 1

あなたは部分的な特殊化を使用することができます。

template<typename TypesTuple> 
struct Bar; 

template<typename... Ts> 
struct Bar<std::tuple<Ts...>> { 
    std::tuple<std::priority_queue<Ts>...> queues; 
}; 

のでmy_bar.queueはタイプstd::tuple<std::priority_queue<int>, std::priority_queue<double>>のものであろう。

Live demo

Answer 2

別の方法：しかし

template<class... Types> 
std::tuple<std::priority_queue<Types...>> convert(std::tuple<Types...>); 

using Foo = decltype(convert(std::declval<std::tuple<int>>()); 

、唯一のタプルは1〜3の要素が含まれている場合に動作し、彼らはstd::priority_queueテンプレート引数の要件、例えば満たしていること：

using Foo = decltype(convert(std::declval<std::tuple<int, std::vector<int>, std::less<int> > >())); 

Answer 3

template<class In, template<class...>class Map> 
struct template_map; 
template<class In, template<class...>class Map> 
using template_map_t=typename template_map<In, Map>::type; 

template<template<class...>class Z, class...Ts, template<class...>class Map> 
struct template_map<Z<Ts...>, Map> { 
    using type=Z<Map<Ts>...>; 
}; 

を

これは、型よりも型である型と、型マップであるndは、囲まれた型をマップでマップした後に型を返します。

template<typename TypesTuple> 
struct Bar { 
    template_map_t<TypesTuple, std::priority_queue> queues; 
}; 

using Foo = Bar<std::tuple<int, double>>; 

書き込みtemplate_map_tは多くの方法で実行できます。

---

私はそれを助言するものではありませだろうが、ここでは花 - スタイルです：

template<class T>struct tag_t{ constexpr tag_t() {}; using type=T; }; 
template<class T>constexpr tag_t<T> tag{}; 

template<template<class...>class Z> 
struct ztemplate_t{ 
    constexpr ztemplate_t() {}; 
    template<class...Ts>using apply=Z<Ts...>; 
}; 
template<template<class...>class Z> 
constexpr ztemplate_t<Z> ztemplate{}; 

これらは、それぞれのタイプやテンプレートを保存constexprの値です。

template<class Z, class...Ts> 
constexpr auto zapply(Z, tag_t<Ts>...) 
-> tag_t< typename Z::template apply<Ts...> > 
{ return {}; } 

zapplyここで値を使用してテンプレートをタイプに適用できるようにします。

template<template<class...>class Z, class...Ts, class zM> 
constexpr auto zmap(tag_t<Z<Ts...>>, zM) 
{ return zapply(ztemplate<Z>, zapply(zM{}, tag<Ts>)...); } 

およびタイプを抽出：

現在、マップ関数を書くことができ

template<class Tag>using type_t=typename Tag::type; 

template<typename TypesTuple> 
struct Bar { 
    using queues_t = type_t<decltype(
    zmap(tag<TypesTuple>, ztemplate<std::priority_queue>) 
)>; 
    queues_t queues; 
}; 

テストコードで：タイプマップを示す

using Foo = Bar<std::tuple<int, double>>; 

tag_t< std::tuple< std::priority_queue<int>, std::priority_queue<double> > > test = tag< decltype(std::declval<Foo&>().queues) >; 

が働きました。

Live example。