C++模板排序

Question

我找模板代码模板参数排序，是这样的：

template <typename T, typename ... Args> 
list<T> sort(T first, Args ... rest) 

所有在args的类型实际上是T，但我需要使用可变参数模板，让我可以小编译像时间列表：

sort(varA, varB, varC, varD). 

（事实上，我打算在具有“all_different”，这将进行排序，并删除重复，以驴如果4个值内翻，varB，VARC，varD都是不同的）。

任何地方这种类型已经写好了？

Answer 1

假设您想对函数参数进行排序，实现起来相当简单。只需从参数中构建一个矢量（或者一个std::list，如果因为任何原因您想使用它）并对其进行分类。

template <typename T, typename ... Args, typename T_d = std::decay_t<T>> 
std::vector<T_d> sort(T&& first, Args&&... rest){ 
    // optionally static assert that all of decay_t<Args>... are the same as T_d 

    // build the vector 
    std::vector<T_d> ret; 
    ret.reserve(1 + sizeof...(Args)); 
    ret.push_back(std::forward<T>(first)); 
    using expander = int[]; 
    (void) expander{0, (ret.push_back(std::forward<Args>(rest)), 0)...}; 

    // now sort it 
    std::sort(ret.begin(), ret.end()); 
    return ret; 
} 

如何expander作品的说明，请参见this answer。

可以缩写“打造载体”的部分为：

std::vector<T_d> ret { std::forward<T>(first), std::forward<Args>(rest)... }; 

但这招致每个元件的额外拷贝（和布展只种不工作），因为你不能从移动一个std::initializer_list。

Answer 2

这个简单：

template <typename T, typename... Args> 
list<T> sort(const T& first, Args... args) 
{ 
    list<T> result{first, args...}; 
    result.sort(); 
    return result; 
} 

Answer 3

做一两件事的时间：

template<class R> 
R sort_the_range(R&& r) { 
    using std::begin; using std::end; 
    std::sort(begin(r), end(r)); 
    return std::forward<R>(r); 
} 

一些元编程：（花样式）

template<class T> struct tag{using type=T;}; 
template<class...> struct types{using type=types;}; 
template<class Tag>using type_t=typename Tag::type; 

template<class Default, class...Ts, 
    class=typename std::enable_if<!std::is_same<void,Default>::value>::type 
> 
constexpr tag<Default> type_from(tag<Default>, Ts...) { return {}; } 
template<class T0, class...Ts> 
constexpr tag<T0> type_from(tag<void>, tag<T0>, Ts...) { return {}; } 

template<class Default, class...Ts> 
using type_from_t = type_t< decltype(type_from(tag<Default>{}, tag<Ts>{}...)) >; 

现在，一个函数，使一个向量。你可以在一个类型传递的载体，或者它的第一个参数推断，你的选择：

// explicit T argument is optional: 
template<class ExplicitType=void, class...Ts, 
    // deduce return type: 
    class R=type_from_t<ExplicitType, typename std::decay<Ts>::type...> 
> 
std::vector<R> make_vector(Ts&&... ts) { 
    // block explicit conversions: 
    using test = decltype(std::array<R, sizeof...(Ts)>{{ std::declval<Ts>()... }}); 
    (void)tag<test>{}; // block warnings 
    // make our vector, and size it right: 
    std::vector<R> retval; 
    retval.reserve(sizeof...(ts)); 
    // populate the vector: 
    (void)std::initializer_list<int>{0,((
    retval.emplace_back(std::forward<Ts>(ts)) 
),void(),0)...}; 
    return retval; 
} 

和缝合：

template<class T=void, class...Ts> 
auto make_sorted_vector(Ts&&...ts) 
->decltype(make_vector<T>(std::forward<Ts>(ts)...)) 
{ 
    return sort_the_range(
    make_vector<T>(std::forward<Ts>(ts)...) 
); 
} 

live example）