[英]How can I do short-circuiting conditionals in a template metaprogram?
我正在模板元程序中實現合並排序。 (信不信由你,我們在生產中有一個真正的用例。)
我的代碼正在運行並且我的測試通過了,但是當我這樣做時,我意識到在Merge
函數中:
using type = typename std::conditional<Compare<L1, R1>::value,
...,
...>::type;
它將實例化分支的兩側,而不僅僅是一側。 這將使時間復雜度變為二次(或更糟的是gulp),而不是n log n
。
如何模仿三元運算符的短路行為? :
? :
在模板元程序中,以便僅完成分支一側的工作?
可悲的是, if constexpr
在這里if constexpr
,我將無法使用C ++ 17,這將是完美的。 它必須在C ++ 14中工作,或更確切地說,是由gcc-5.4
實現的C ++ 14的子集
我最初的想法是像這樣使用SFINAE:
template <typename L1, typename R1,
typename <typename, typename> typename Compare,
typename TL, typename TR,
std::enable_if_t<Compare<L1, R1>::value> * dummy = nullptr>
Concat<TypeList<L1>, Merge_s<TL, Concat<TypeList<R1>, TR>, C> merge_branch();
template <typename L1, typename R1,
typename <typename, typename> typename Compare,
typename TL, typename TR,
std::enable_if_t<!Compare<L1, R1>::value> * dummy = nullptr>
Concat<TypeList<R1>, Merge_s<Concat<TypeList<L1>, TL>, TR, C> merge_branch();
但是,我不確定這是否會按照預期的方式工作-當模板參數的推導在上述dummy
上失敗時,是否會阻止編譯器實例化返回類型? 我是否應該使用額外級別的間接(甚至會有所幫助嗎?)
建議我可以使用標簽分發代替SFINAE。
模板實例化是作為過載解析的副產品發生的,還是僅在過載解析完成后才發生?
我擔心答案是過載解決的副產品。
當上面的參數dummy
失敗時,gcc和clang是否會從實例化模板中提早解脫,還是它們總是實例化返回類型?
這是我的MVCE:
#include <cstddef>
#include <type_traits>
#include <utility>
template <typename ... Ts>
struct TypeList {
static constexpr size_t size = sizeof...(Ts);
};
// Metafunction First: Get first type from a typelist
template<typename T>
struct First_s;
template<typename T, typename... TL>
struct First_s <TypeList<T, TL...>> {
using type = T;
};
template<typename T>
using First = typename First_s<T>::type;
// Metafunction Concat: Concatenate two typelists
template<typename L, typename R>
struct Concat_s;
template<typename... TL, typename... TR>
struct Concat_s <TypeList<TL...>, TypeList<TR...>> {
using type = TypeList<TL..., TR...>;
};
template<typename L, typename R>
using Concat = typename Concat_s<L,R>::type;
// Metafunction Split: Split a typelist at a particular index
template<int i, typename TL>
struct Split;
template<int k, typename... TL>
struct Split<k, TypeList<TL...>> {
private:
using FirstSplit = Split<k/2, TypeList<TL...>>;
using SecondSplit = Split<k-k/2, typename FirstSplit::R>;
public:
using L = Concat<typename FirstSplit::L, typename SecondSplit::L>;
using R = typename SecondSplit::R;
};
template<typename T, typename... TL>
struct Split<0, TypeList<T, TL...>> {
using L = TypeList<>;
using R = TypeList<T, TL...>;
};
template<typename T, typename... TL>
struct Split<1, TypeList<T, TL...>> {
using L = TypeList<T>;
using R = TypeList<TL...>;
};
template<int k>
struct Split<k, TypeList<>> {
using L = TypeList<>;
using R = TypeList<>;
};
// Metafunction Subdivide: Split a typelist into two roughly equal typelists
template<typename TL>
struct Subdivide : Split<TL::size / 2, TL> {};
// Metafunction Reverse: Reverse a typelist
template <typename TL>
struct Reverse_s {
using S = Subdivide<TL>;
using type = Concat<typename Reverse_s<typename S::R>::type,
typename Reverse_s<typename S::L>::type>;
};
template <typename T>
struct Reverse_s<TypeList<T>> {
using type = TypeList<T>;
};
template <>
struct Reverse_s<TypeList<>> {
using type = TypeList<>;
};
template <typename TL>
using Reverse = typename Reverse_s<TL>::type;
// Metafunction MergeSort: Mergesort a typelist, using a comparator C
// Merge takes two type lists, and a comparator metafunction.
// The comparator should take two type parameters and declare `static constexpr bool value = ...`
template <typename TL, typename TR, template <typename, typename> class C>
struct Merge_s;
// TODO: Use SFINAE for the branch here because std::conditional does not short circuit :(
/*
template <typename L1, typename R1, typename <typename, typename> typename C, typename TL, typename TR, std::enable_if_t<C<L1, R1>::value> * dummy = nullptr>
Concat<TypeList<L1>, Merge_s<TL, Concat<TypeList<R1>, TR>, C> merge_branch();
template <typename L1, typename R1, typename <typename, typename> typename C, typename TL, typename TR, std::enable_if_t<!C<L1, R1>::value> * dummy = nullptr>
Concat<TypeList<R1>, Merge_s<Concat<TypeList<L1>, TL>, TR, C> merge_branch();
*/
template <template <typename, typename> class C>
struct Merge_s<TypeList<>, TypeList<>, C> {
using type = TypeList<>;
};
template <typename L1, typename ... Ls, template <typename, typename> class C>
struct Merge_s<TypeList<L1, Ls...>, TypeList<>, C> {
using type = TypeList<L1, Ls...>;
};
template <typename R1, typename ... Rs, template <typename, typename> class C>
struct Merge_s<TypeList<>, TypeList<R1, Rs...>, C> {
using type = TypeList<R1, Rs...>;
};
template <typename L1, typename R1, template <typename, typename> class C, typename TL, typename TR>
using merge_branch = typename std::conditional<C<L1, R1>::value,
Concat<TypeList<L1>, typename Merge_s<TL, Concat<TypeList<R1>, TR>, C>::type>,
Concat<TypeList<R1>, typename Merge_s<Concat<TypeList<L1>, TL>, TR, C>::type>>::type;
template <typename L1, typename... Ls, typename R1, typename ... Rs, template <typename, typename> class C>
struct Merge_s<TypeList<L1, Ls...>, TypeList<R1, Rs...>, C> {
using type = merge_branch<L1, R1, C, TypeList<Ls...>, TypeList<Rs...>>;
};
template <typename TL, typename TR, template <typename, typename> class C>
using Merge = typename Merge_s<TL, TR, C>::type;
// Here is merge sort
template <typename T, template <typename, typename> class C>
struct MergeSort_s;
template <template <typename, typename> class C>
struct MergeSort_s<TypeList<>, C> {
using type = TypeList<>;
};
template <typename T, template <typename, typename> class C>
struct MergeSort_s<TypeList<T>, C> {
using type = TypeList<T>;
};
template <typename T, typename... Ts, template <typename, typename> class C>
struct MergeSort_s <TypeList<T, Ts...>, C>{
using S = Subdivide<TypeList<T, Ts...>>;
using L = typename MergeSort_s<typename S::L, C>::type;
using R = typename MergeSort_s<typename S::R, C>::type;
using type = Merge<L, R, C>;
};
template <typename T, template <typename, typename> class C>
using MergeSort = typename MergeSort_s<T, C>::type;
// Tests
struct A{};
struct B{};
struct C{};
// Concat tests
static_assert(std::is_same<TypeList<A, B, C>, //
Concat<TypeList<>, TypeList<A, B, C>>>::value, ""); //
static_assert(std::is_same<TypeList<A, B, C>, //
Concat<TypeList<A>, TypeList<B, C>>>::value, ""); //
static_assert(std::is_same<TypeList<A, B, C>, //
Concat<TypeList<A, B>, TypeList<C>>>::value, ""); //
static_assert(std::is_same<TypeList<A, B, C>, //
Concat<TypeList<A, B, C>, TypeList<>>>::value, ""); //
// Split tests
static_assert(std::is_same<TypeList<A>, //
typename Split<1, TypeList<A, B, C>>::L>::value, ""); //
static_assert(std::is_same<TypeList<B, C>, //
typename Split<1, TypeList<A, B, C>>::R>::value, ""); //
static_assert(std::is_same<TypeList<A, B>, //
typename Split<2, TypeList<A, B, C>>::L>::value, ""); //
static_assert(std::is_same<TypeList<C>, //
typename Split<2, TypeList<A, B, C>>::R>::value, ""); //
// Reverse tests
static_assert(std::is_same<TypeList<B, A>, //
Reverse<TypeList<A, B>>>::value, ""); //
static_assert(std::is_same<TypeList<C, B, A>,//
Reverse<TypeList<A, B, C>>>::value, ""); //
// Sorting tests
template <typename T1, typename T2>
struct IntCmp;
template <int a, int b>
struct IntCmp<std::integral_constant<int, a>, std::integral_constant<int, b>> {
static constexpr bool value = (a < b);
};
template <int x>
using IntC = std::integral_constant<int, x>;
static_assert(std::is_same<TypeList<IntC<1>, IntC<2>>, //
MergeSort<TypeList<IntC<1>, IntC<2>>, IntCmp>>::value, ""); //
static_assert(std::is_same<TypeList<IntC<1>, IntC<2>>,//
MergeSort<TypeList<IntC<2>, IntC<1>>, IntCmp>>::value, "");//
static_assert(std::is_same<TypeList<IntC<1>, IntC<2>, IntC<3>>,//
MergeSort<TypeList<IntC<3>, IntC<1>, IntC<2>>, IntCmp>>::value, "");//
static_assert(std::is_same<TypeList<IntC<1>, IntC<2>, IntC<3>>,//
MergeSort<TypeList<IntC<1>, IntC<3>, IntC<2>>, IntCmp>>::value, "");//
static_assert(std::is_same<TypeList<IntC<1>, IntC<2>, IntC<3>>,//
MergeSort<TypeList<IntC<2>, IntC<3>, IntC<1>>, IntCmp>>::value, "");//
static_assert(std::is_same<TypeList<IntC<1>, IntC<2>, IntC<3>>,//
MergeSort<TypeList<IntC<1>, IntC<2>, IntC<3>>, IntCmp>>::value, "");//
static_assert(std::is_same<TypeList<IntC<1>, IntC<2>, IntC<3>>,//
MergeSort<TypeList<IntC<2>, IntC<1>, IntC<3>>, IntCmp>>::value, "");//
static_assert(std::is_same<TypeList<IntC<1>, IntC<2>, IntC<3>>,//
MergeSort<TypeList<IntC<1>, IntC<2>, IntC<3>>, IntCmp>>::value, "");//
static_assert(std::is_same<TypeList<IntC<1>, IntC<2>, IntC<3>, IntC<4>>,//
MergeSort<TypeList<IntC<1>, IntC<2>, IntC<3>, IntC<4>>, IntCmp>>::value, "");//
static_assert(std::is_same<TypeList<IntC<1>, IntC<2>, IntC<3>, IntC<4>>,//
MergeSort<TypeList<IntC<3>, IntC<4>, IntC<2>, IntC<1>>, IntCmp>>::value, "");//
我建議通過部分專業化的幫助結構
template <typename L1, typename R1, template <typename, typename> class C,
typename TL, typename TR, bool = C<L1, R1>::value>
struct merge_branch_h
{ using type = Concat<TypeList<L1>,
typename Merge_s<TL, Concat<TypeList<R1>, TR>, C>::type>; };
template <typename L1, typename R1, template <typename, typename> class C,
typename TL, typename TR>
struct merge_branch_h<L1, R1, C, TL, TR, false>
{ using type = Concat<TypeList<R1>,
typename Merge_s<Concat<TypeList<L1>, TL>, TR, C>::type>; };
template <typename L1, typename R1, template <typename, typename> class C,
typename TL, typename TR>
using merge_branch = typename merge_branch_h<L1, R1, C, TL, TR>::type;
添加額外的間接層。 Boost.MPL具有稱為eval_if
此元函數,它類似於conditional
只是不采用兩種類型,而是采用了兩個無效元函數並求值一個或另一個。 它非常容易實現:
template <bool B, typename T1, typename T2>
using eval_if = typename std::conditional<B, T1, T2>::type::type;
因此,讓我們添加一個元函數來進行串聯/合並:
template <typename T>
struct identity {
using type = T;
};
template <typename L, typename R>
struct delay_concat {
using type = Concat<typename L::type, typename R::type>;
};
然后,您可以交換您的:
typename std::conditional<C<L1, R1>::value,
Concat<TypeList<L1>, typename Merge_s<TL, Concat<TypeList<R1>, TR>, C>::type>,
Concat<TypeList<R1>, typename Merge_s<Concat<TypeList<L1>, TL>, TR, C>::type>
有:
eval_if<C<L1, R1>::value,
delay_concat<identity<TypeList<L1>>, Merge_s<TL, Concat<TypeList<R1>, TR>, C>>,
delay_concat<identity<TypeList<R1>>, Merge_s<Concat<TypeList<L1>, TL>, TR, C>>>
會短路。
可能應該概括為:
template <template <typename...> class Z, typename... Ts>
struct delay_eval {
using type = Z<typename Ts::type...>;
};
然后將TypeList
一個產生自身的元函數,因此我們不必將它們包裝在identity
。 這允許:
eval_if<C<L1, R1>::value,
delay_eval<Concat, TypeList<L1>, delay_eval<Merge_s, TL, delay_eval<Concat, TypeList<R1>, TR>, C>>,
delay_eval<Concat, TypeList<R1>, delay_eval<Merge_s, delay_eval<Concat, TypeList<L1>, TL>, TR, C>>>
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.