Question

我正在寻找模板代码来对模板参数进行排序，例如：

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

Args中的所有类型实际上都是T，但我需要使用可变参数模板，这样我就可以编写小编译时间列表：

sort(varA, varB, varC, varD).

（事实上，我计划有一个＆＃34; all_different＆＃34;，它会排序和删除重复项，以评估4个值varA，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。

你可以缩短＆＃34;构建向量＆＃34;部分进入：

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

但是这会产生每个元素的额外副本（并且不适用于仅限移动类型），因为您无法从std::initializer_list移动。

Answer 2

一次做一件事：

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

一些元编程:( hana风格）

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）

Answer 3

这很简单：

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

C ++模板排序

3 个答案: