[英]Generate a new integer_sequence by removing duplicates
我實現了編譯時檢查,以檢查是否使用下面給出的代碼對某些內容進行了排序:
template<typename IntegerSequence>
struct is_sorted {
static constexpr bool value = true;
};
template<typename Integer, Integer Head, Integer Next, Integer... Tail>
struct is_sorted<std::integer_sequence<Integer, Head, Next, Tail...>> {
static constexpr bool value = Head <= Next && is_sorted<std::integer_sequence<Integer, Next, Tail...>>::value;
};
上面的代碼有效。 我計划使用這些排序檢查創建兩個額外的元 function,這將生成沒有重復的新序列
using in_seq = std::integer_sequence<int, 1,2,3,4>;
using mod_seq = is_sorted<in_seq>::value ? remove_duplicates<in_seq>::uniq_seq : in_seq;
// Examples
// in_seq = 1,2,3,4 -> mod_seq = 1,2,3,4
// in_seq = 1,2,2,3,4 -> mod_seq = 1,2,3,4
如何在編譯時使用模板從 integer 序列中刪除重復項。 在我們執行排序檢查時是否可以刪除重復項,在這種情況下,如果我們在模板檢測到該序列未排序時立即停止刪除重復項,我很好。
// partial sort example 4,4,4,5,5,3,2,2,1 -> 4,5,3,2,2,1 (not sure if this is possible, but just curious)
我不確定如何通過動態生成新的std::integer_sequence
來 go 。
由於所有 std 算法現在在 C++20 中都是constexpr
,我們可以使用它以自然方式進行編譯時編程(就像@cigien說的那樣):
template <typename T, T... Ints>
constexpr auto unique_until_nonsorted(std::integer_sequence<T, Ints...>) {
// constexpr structured bindings are not allow :(
constexpr auto pair = [] {
std::array<T, sizeof...(Ints)> arr{Ints...};
// get last iterator of unique
auto sorted_end = std::is_sorted_until(arr.begin(), arr.end());
// unique until last iterator
auto unique_end = std::unique(arr.begin(), sorted_end);
// copy nonsorted elements to last iterator
auto copy_end = std::copy(sorted_end, arr.end(), unique_end);
// get final arr size
auto size = std::distance(arr.begin(), copy_end);
return std::pair{arr, size};
}();
constexpr auto arr = pair.first;
constexpr auto size = pair.second;
// using template lambda to expand pack
return [&arr]<std::size_t... Is>(std::index_sequence<Is...>) {
return std::integer_sequence<T, arr[Is]...>{};
}(std::make_index_sequence<size>{});
}
template <typename X, X... Xs, typename Y, Y... Ys>
constexpr bool operator==(std::integer_sequence<X, Xs...>,
std::integer_sequence<Y, Ys...>) noexcept {
return ((Xs == Ys) && ...);
}
static_assert(unique_until_nonsorted(std::index_sequence<4,4,4,5,5,3,2,2,1>{}) ==
std::index_sequence<4,5,3,2,2,1>{});
static_assert(unique_until_nonsorted(std::index_sequence<1,2,3,4>{}) ==
std::index_sequence<1,2,3,4>{});
static_assert(unique_until_nonsorted(std::index_sequence<1,2,2,3,4>{}) ==
std::index_sequence<1,2,3,4>{});
static_assert(unique_until_nonsorted(std::index_sequence<2,2,2,2,4,1,1>{}) ==
std::index_sequence<2,4,1,1>{});
static_assert(unique_until_nonsorted(std::index_sequence<1,1,1,2,3,2,2>{}) ==
std::index_sequence<1,2,3,2,2>{});
// corner case
static_assert(unique_until_nonsorted(std::index_sequence<>{}) ==
std::index_sequence<>{});
在我們執行排序檢查時是否可以刪除重復項,在這種情況下,如果我們在模板檢測到該序列未排序時立即停止刪除重復項,我很好。
是的,這是可能的。
也許可以做得更簡單一些,但是......使用和濫用模板專業化......
給定一個助手 class 如下
// csardh: check sort and remove duplicates helper
template <typename T, typename>
struct csardh
{ using type = T; };
template <typename T, T ... ordered, T v0, T v1, T ... vs>
struct csardh<std::integer_sequence<T, ordered...>,
std::integer_sequence<T, v0, v1, vs...>>
: public std::conditional_t<
(v0 < v1),
csardh<std::integer_sequence<T, ordered..., v0>,
std::integer_sequence<T, v1, vs...>>,
csardh<std::integer_sequence<T, ordered..., v0, v1, vs...>, void>>
{ };
template <typename T, T ... ordered, T v0, T ... vs>
struct csardh<std::integer_sequence<T, ordered...>,
std::integer_sequence<T, v0, v0, vs...>>
: public csardh<std::integer_sequence<T, ordered...>,
std::integer_sequence<T, v0, vs...>>
{ };
template <typename T, T ... ordered, T v0>
struct csardh<std::integer_sequence<T, ordered...>,
std::integer_sequence<T, v0>>
: public csardh<std::integer_sequence<T, ordered..., v0>, void>
{ };
主class變成
// csard: check sort and remove duplicates
template <typename>
struct csard;
template <typename T, T... vals>
struct csard<std::integer_sequence<T, vals...>>
: public csardh<std::integer_sequence<T>,
std::integer_sequence<T, vals...>>
{ };
using
可用於簡化使用
template <typename T>
using csard_t = typename csard<T>::type;
下面是一個完整的編譯例子(C++14就夠了)
#include <utility>
#include <type_traits>
// csardh: check sort and remove duplicates helper
template <typename T, typename>
struct csardh
{ using type = T; };
template <typename T, T ... ordered, T v0, T v1, T ... vs>
struct csardh<std::integer_sequence<T, ordered...>,
std::integer_sequence<T, v0, v1, vs...>>
: public std::conditional_t<
(v0 < v1),
csardh<std::integer_sequence<T, ordered..., v0>,
std::integer_sequence<T, v1, vs...>>,
csardh<std::integer_sequence<T, ordered..., v0, v1, vs...>, void>>
{ };
template <typename T, T ... ordered, T v0, T ... vs>
struct csardh<std::integer_sequence<T, ordered...>,
std::integer_sequence<T, v0, v0, vs...>>
: public csardh<std::integer_sequence<T, ordered...>,
std::integer_sequence<T, v0, vs...>>
{ };
template <typename T, T ... ordered, T v0>
struct csardh<std::integer_sequence<T, ordered...>,
std::integer_sequence<T, v0>>
: public csardh<std::integer_sequence<T, ordered..., v0>, void>
{ };
// csard: check sort and remove duplicates
template <typename>
struct csard;
template <typename T, T... vals>
struct csard<std::integer_sequence<T, vals...>>
: public csardh<std::integer_sequence<T>,
std::integer_sequence<T, vals...>>
{ };
template <typename T>
using csard_t = typename csard<T>::type;
int main()
{
using T0 = std::integer_sequence<int,4,4,4,5,5,3,2,2,1>;
using T1 = csard_t<T0>;
using T2 = std::integer_sequence<int,4,5,3,2,2,1>;
static_assert( std::is_same<T1, T2>::value, "!" );
using U0 = std::integer_sequence<int,1,2,3,4>;
using U1 = csard_t<U0>;
using U2 = U0;
static_assert( std::is_same<U1, U2>::value, "!" );
using V0 = std::integer_sequence<int,1,2,2,3,4>;
using V1 = csard_t<V0>;
using V2 = U2;
static_assert( std::is_same<V1, V2>::value, "!" );
}
讓我們用Boost.Mp11來做這件事。 在那里,“整數序列”的概念有點不同,我們處理類型列表。 mp_list_c<int, 1, 2>
是類型mp_list<mp_int<1>, mp_int<2>>
。 這使得很多元編程變得更加容易。 這里的一切都是單線的。
首先, is_sorted
。 Mp11 (shocker) 目前缺少的一種算法是執行zip_with
的能力 - 也就是說,獲取一個列表和 zip 該列表,該列表自身偏移一:
template <typename L, template <typename...> class P>
using zip_with = mp_transform<P, mp_pop_back<L>, mp_pop_front<L>>;
現在, is_sorted
基本上是:獲取該列表並檢查每對的第一個元素是否小於第二個:
template <typename L>
using is_sorted = mp_rename<zip_with<L, mp_less>, mp_all>;
刪除重復項? 這就是已經有一種算法的東西: mp_unique
。
總而言之:
using mod_seq = mp_if_c<is_sorted<L>::value, mp_unique<L>, L>;
類型沒有條件運算符,您需要類似mp_if
(或std::conditional_t
)的東西。
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.