- html - 出于某种原因,IE8 对我的 Sass 文件中继承的 html5 CSS 不友好?
- JMeter 在响应断言中使用 span 标签的问题
- html - 在 :hover and :active? 上具有不同效果的 CSS 动画
- html - 相对于居中的 html 内容固定的 CSS 重复背景?
我正在模板元程序中实现合并排序。 (信不信由你,我们在生产中有一个真实的用例。)
我的代码正在运行并且我的测试正在通过,但是我意识到在 Merge
函数中,当我这样做时:
using type = typename std::conditional<Compare<L1, R1>::value,
...,
...>::type;
它将实例化分支的两侧,而不仅仅是一侧。这将使时间复杂度变为二次方(或更糟?一口气)而不是 n log n
。
如何模仿三元运算符 的短路行为? :
在模板元程序中,只完成分支一侧的工作?
不幸的是,我不能在这里使用 C++17 if constexpr
,这将是完美的。它必须在 C++14 中工作,或者更确切地说,是 gcc-5.4
我最初的想法是像这样使用 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, "");//
归属:以上部分细节由Yakk's comments告知在另一个答案中
最佳答案
添加一个额外的间接层。 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>>>
关于c++ - 如何在模板元程序中做短路条件?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/47538917/
我正在努力处理查询的 WHERE 部分。查询本身包含一个基于两个表中都存在的 ID 的 LEFT JOIN。但是,我要求 where 语句仅返回其中一列中存在的最大单个结果。目前我返回连接中的所有值,
我有这个代码来改变文件系统的大小。问题是,即使满足 if 条件,它也不会进入 if 条件,而我根本没有检查 if 条件。它直接进入 else 条件。 运行代码后的结果 post-install-ray
假设我有一个包含 2 列的 Excel 表格:单元格 A1 到 A10 中的日期和 B1 到 B10 中的值。 我想对五月日期的所有值求和。我有3种可能性: {=SUM((MONTH(A1:A10)=
伪代码: SELECT * FROM 'table' WHERE ('date' row.date 或 ,我们在Stack Overflow上找到一个类似的问题: https://stackove
我有下面这行代码做一个简单的查询 if ($this->fulfilled) $criteria->addCondition('fulfilled ' . (($this->fulfilled
如果在数据库中找到用户输入的键,我将尝试显示“表”中的数据。目前我已将其设置为让数据库检查 key 是否存在,如下所示: //Select all from table if a key entry
关闭。此题需要details or clarity 。目前不接受答案。 想要改进这个问题吗?通过 editing this post 添加详细信息并澄清问题. 已关闭 5 年前。 Improve th
在MYSQL中可以吗 一共有三个表 任务(task_id、task_status、...) tasks_assigned_to(ta_id、task_id、user_id) task_suggeste
我想先根据用户的状态然后根据用户名来排序我的 sql 请求。该状态由 user_type 列设置: 1=活跃,2=不活跃,3=创始人。 我会使用此请求来执行此操作,但它不起作用,因为我想在“活跃”成员
下面两个函数中最专业的代码风格是什么? 如果函数变得更复杂和更大,例如有 20 个检查怎么办? 注意:每次检查后我都需要做一些事情,所以我不能将所有内容连接到一个 if 语句中,例如: if (veh
我在 C# 项目中使用 EntityFramework 6.1.3 和 SQL Server。我有两个查询,基本上应该执行相同的操作。 1. Exams.GroupBy(x=>x.SubjectID)
我试图在 case when 语句中放入两个条件,但我在 postgresql 中遇到语法错误 case when condition 1 and condition 2 then X else Y
我正在构建一个连接多个表的查询,一个表 prodRecipe 将包含某些行的数据,但不是全部,但是 tmp_inv1 将包含所有行的计数信息。问题是,tmp_inv1.count 取决于某个项目是否在
我有一个涉及 couples of rows which have a less-than-2-hours time-difference 的查询(~0.08333 天): SELECT mt1.*,
我有一个包含许多这样的 OR 条件的代码(工作正常)来检查其中一个值是否为空,然后我们抛出一条错误消息(所有这些都必须填写) } elsif ( !$params{'account'}
我有一个名为 spGetOrders 的存储过程,它接受一些参数:@startdate 和 @enddate。这将查询“订单”表。表中的一列称为“ClosedDate”。如果订单尚未关闭,则此列将保留
在代码中,注释部分是我需要解决的问题...有没有办法在 LINQ 中编写这样的查询?我需要这个,因为我需要根据状态进行排序。 var result = ( from contact in d
我正在尝试创建一个允许省略参数的存储过程,但如果提供了参数,则进行 AND 操作: CREATE PROCEDURE MyProcedure @LastName Varchar(30)
我正在寻找一种方法来过滤我的主机文件中的新 IP 地址。我创建了一个脚本,每次我用来自矩阵企业管理器的数据调用它时都会更新我的主机文件。它工作正常。但是我必须找到一个解决方案,只允许更新 10.XX.
所以我正在做一种 slider ,当它完全向下时隐藏向下按钮,反之亦然,当向上按钮隐藏时,我遇到了问题。 var amount = $('slide').attr('number'); $('span
我是一名优秀的程序员,十分优秀!