我正在实现可变参数的最小/最大函数。一个目标是利用编译时已知数量的参数并执行展开式评估(避免运行时循环)。代码的当前状态如下(表示min-max相似)
#include <iostream>
using namespace std;
template<typename T>
T vmin(T val1, T val2)
{
return val1 < val2 ? val1 : val2;
}
template<typename T, typename... Ts>
T vmin(T val1, T val2, Ts&&... vs)
{
return val1 < val2 ?
vmin(val1, std::forward<Ts>(vs)...) :
vmin(val2, std::forward<Ts>(vs)...);
}
int main()
{
cout << vmin(3, 2, 1, 2, 5) << endl;
cout << vmin(3., 1.2, 1.3, 2., 5.2) << endl;
return 0;
}
现在可以使用,但是我有一些问题/疑问:
该非可变参数过载有由价值接受它的参数。如果我尝试传递其他类型的ref,则会得到以下结果
&&
->编译错误const&
->确定&
->编译错误现在,我知道功能模板与模板混合在一起很奇怪,但是手头上是否有特定的专有技术?我应该选择哪种类型的参数?
不能充分扩展参数包吗?我是否真的需要将参数转发给递归调用?
将其包装在结构中并公开为静态成员函数时,是否可以更好地实现此功能。能专攻我的东西会给我买什么吗?
功能版本是否有更健壮/高效的实现/设计?(特别是我想知道一个constexpr
版本是否适合模板元编程的效率)
这样可以完美地转发参数。它依赖RVO来获取返回值,因为无论输入类型如何,它都会返回值类型,因为common_type
这样做是。
我实现了common_type
推论,允许传入混合类型,并输出“预期”结果类型。
我们支持1个元素的最小值,因为它会使代码更加流畅。
#include <utility>
#include <type_traits>
template<typename T>
T vmin(T&&t)
{
return std::forward<T>(t);
}
template<typename T0, typename T1, typename... Ts>
typename std::common_type<
T0, T1, Ts...
>::type vmin(T0&& val1, T1&& val2, Ts&&... vs)
{
if (val2 < val1)
return vmin(val2, std::forward<Ts>(vs)...);
else
return vmin(val1, std::forward<Ts>(vs)...);
}
int main()
{
std::cout << vmin(3, 2, 0.9, 2, 5) << std::endl;
std::cout << vmin(3., 1.2, 1.3, 2., 5.2) << std::endl;
return 0;
}
现在,尽管以上是一个完全可以接受的解决方案,但它并不理想。
该表达式((a<b)?a:b) = 7
是合法的C ++,但vmin( a, b ) = 7
不是,因为std::common_type
decay
s是盲目的参数(由我认为是对它的过度反应所致,当在较旧的实现中使用两种值类型时,返回rvalue引用会导致这种情况std::common_type
)。
简单地使用decltype( true?a:b )
是很诱人的,但是它既会导致右值引用问题,又不支持common_type
专业化(例如std::chrono
)。所以我们都想使用common_type
,也不想使用它。
其次,编写min
不支持无关指针并且不让用户更改比较函数的函数似乎是错误的。
因此,下面是上述内容的更复杂版本。现场示例:
#include <iostream>
#include <utility>
#include <type_traits>
namespace my_min {
// a common_type that when fed lvalue references all of the same type, returns an lvalue reference all of the same type
// however, it is smart enough to also understand common_type specializations. This works around a quirk
// in the standard, where (true?x:y) is an lvalue reference, while common_type< X, Y >::type is not.
template<typename... Ts>
struct my_common_type;
template<typename T>
struct my_common_type<T>{typedef T type;};
template<typename T0, typename T1, typename... Ts>
struct my_common_type<T0, T1, Ts...> {
typedef typename std::common_type<T0, T1>::type std_type;
// if the types are the same, don't change them, unlike what common_type does:
typedef typename std::conditional< std::is_same< T0, T1 >::value,
T0,
std_type >::type working_type;
// Careful! We do NOT want to return an rvalue reference. Just return T:
typedef typename std::conditional<
std::is_rvalue_reference< working_type >::value,
typename std::decay< working_type >::type,
working_type
>::type common_type_for_first_two;
// TODO: what about Base& and Derived&? Returning a Base& might be the right thing to do.
// on the other hand, that encourages silent slicing. So maybe not.
typedef typename my_common_type< common_type_for_first_two, Ts... >::type type;
};
template<typename... Ts>
using my_common_type_t = typename my_common_type<Ts...>::type;
// not that this returns a value type if t is an rvalue:
template<typename Picker, typename T>
T pick(Picker&& /*unused*/, T&&t)
{
return std::forward<T>(t);
}
// slight optimization would be to make Picker be forward-called at the actual 2-arg case, but I don't care:
template<typename Picker, typename T0, typename T1, typename... Ts>
my_common_type_t< T0, T1, Ts...> pick(Picker&& picker, T0&& val1, T1&& val2, Ts&&... vs)
{
// if picker doesn't prefer 2 over 1, use 1 -- stability!
if (picker(val2, val1))
return pick(std::forward<Picker>(pick), val2, std::forward<Ts>(vs)...);
else
return pick(std::forward<Picker>(pick), val1, std::forward<Ts>(vs)...);
}
// possibly replace with less<void> in C++1y?
struct lesser {
template<typename LHS, typename RHS>
bool operator()( LHS&& lhs, RHS&& rhs ) const {
return std::less< typename std::decay<my_common_type_t<LHS, RHS>>::type >()(
std::forward<LHS>(lhs), std::forward<RHS>(rhs)
);
}
};
// simply forward to the picked_min function with a smart less than functor
// note that we support unrelated pointers!
template<typename... Ts>
auto min( Ts&&... ts )->decltype( pick( lesser(), std::declval<Ts>()... ) )
{
return pick( lesser(), std::forward<Ts>(ts)... );
}
}
int main()
{
int x = 7;
int y = 3;
int z = -1;
my_min::min(x, y, z) = 2;
std::cout << x << "," << y << "," << z << "\n";
std::cout << my_min::min(3, 2, 0.9, 2, 5) << std::endl;
std::cout << my_min::min(3., 1.2, 1.3, 2., 5.2) << std::endl;
return 0;
}
上述实现的不利之处在于,大多数类都不支持operator=(T const&)&&=delete
-即,它们不会阻止将rvalue赋值给它,如果min
not中的一种类型,可能会导致意外情况。基本类型呢。
附带说明:开始删除右值引用operator=
的人员。
本文收集自互联网,转载请注明来源。
如有侵权,请联系[email protected] 删除。
我来说两句