映射一個std ::元組到另一個的std ::元組

Question

假設我有一個std::tuple<Types...>，我想生成一個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>>; 

那怎麼可以實現？

編輯

它能否通過的boost ::元組或矢量和改造更容易？可以將變換應用於元層面嗎？

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。