C ++ 11具有函数std::minmax_element
,它返回一对值。然而,这对于处理和读取来说是相当混乱的,并且产生一个额外的,后来无用的变量来污染范围。
auto lhsMinmax = std::minmax_element(lhs.begin(), lhs.end());
int &lhsMin = *(lhsMinMax.first);
int &lhsMax = *(lhsMinmax.second);
有一个更好的方法吗?就像是:
int lhsMin;
int lhsMax;
std::make_pair<int&, int&>(lhsMin, lhsMax).swap(
std::minmax_element(lhs.begin(), lhs.end()));
这似乎足以提示辅助函数:
template <class T, std::size_t...Idx>
auto deref_impl(T &&tuple, std::index_sequence<Idx...>) {
return std::tuple<decltype(*std::get<Idx>(std::forward<T>(tuple)))...>(*std::get<Idx>(std::forward<T>(tuple))...);
}
template <class T>
auto deref(T &&tuple)
-> decltype(deref_impl(std::forward<T>(tuple), std::make_index_sequence<std::tuple_size<std::remove_reference_t<T>>::value>{})) {
return deref_impl(std::forward<T>(tuple), std::make_index_sequence<std::tuple_size<std::remove_reference_t<T>>::value>{});
}
// ...
int lhsMin;
int lhsMax;
std::tie(lhsMin,lhsMax) = deref(std::minmax_element(lhs.begin(), lhs.end()));
index_sequence
是C ++ 14,但是完整的实现can be made in C++11。
注意:即使在C ++ 14中,我也会在decltype
的返回类型中保留重复的deref
,以便SFINAE可以应用。
使用C ++ 17的结构化绑定,您可以直接执行
auto [lhsMinIt, lhsMaxIt] = std::minmax_element(lhs.begin(), lhs.end());
为避免污染范围,可以将赋值括在较小的范围内:
int lhsMin, lhsMax;
{
auto it = std::minmax_element(lhs.begin(), lhs.end());
lhsMin = *it.first;
lhsMax = *it.second;
}
或者,你可以使用lambda
int lhsMin, lhsMax;
std::tie(lhsMin, lhsMax) = [&]{
auto it = std::minmax_element(lhs.begin(), lhs.end());
return std::make_tuple(*it.first, *it.second);
}();
我会更直接地写我自己的minmax_element
版本:
template <class Iter, class R = typename iterator_traits<Iter>::reference>
std::pair<R,R> deref_minmax(Iter first, Iter last)
{
auto iters = std::minmax_element(first, last);
return std::pair<R,R>{*iters.first, *iters.second};
}
那就是:
int lo, hi;
std::tie(lo, hi) = deref_minmax(lhs.begin(), lhs.end());
这将限制你只需要一个元素的副本(这与int
s没有多大关系),也让你保持对实际容器的引用的访问。
在C ++ 17中,为了好玩,我们可以编写一个通用的解引用器:
template <class Tuple>
auto deref(Tuple&& tup) {
return std::apply([](auto... args) {
return std::tuple <decltype(*args)...>(*args...);
}, tup);
}
auto& [lo, hi] = deref(std::minmax_element(lhs.begin(), lhs.end()));
这里lo
和hi
是容器本身的引用。
如果这就是您所追求的目标,那么在标准的当前版本中无法一次分配两个引用。请注意,除了需要C ++ 17和辅助模板的Barry之外,没有其他答案可以做到这一点。
但是,如果您希望对最小和最大元素进行读写访问,为什么不直接使用minmax_element
直接为您提供的迭代器?无论如何,它可能会生成与使用参考相同的机器代码,至少如果你的lhs
是ContiguousContainer
,但也可能在其他情况下。
例如,您需要更少依赖自动类型扣除
decltype(lhs.begin()) lhsMinIt, lhsMaxIt;
std::tie(lhsMinIt, lhsMaxIt) = std::minmax_element(lhs.begin(), lhs.end());
/* now access your minimum and maximum as *lhsMinIt and *lhsMaxIt */
如果您知道lhs
的类型将是标准容器之一,您可以使用更清洁的类型名称decltype(lhs)::iterator
。
在C ++ 14或更高版本中
template<class=void, std::size_t...Is>
auto indexer( std::index_sequence<Is...> ) {
return [](auto&&f){
return f( std::integral_constant<std::size_t, Is>{}... );
};
}
template<std::size_t N>
auto indexer() {
return indexer( std::make_index_sequence<N>{} );
}
template<class F>
auto fmap_over_tuple( F&& f ) {
return [f=std::forward<F>(f)](auto&& tuple) {
using Tuple = decltype(tuple);
using Tuple_d = std::decay_t<Tuple>;
auto index = indexer< std::tuple_size< Tuple_d >::value >();
return index(
[&f, &tuple](auto&&...Is) {
using std::get;
return std::make_tuple(
f( get<Is>( std::forward<Tuple>(tuple) ) )...
);
}
);
};
}
所以fmap_over_tuple
采用了一个函数对象。它返回一个函数对象,当传递一个类似元组时,继续调用类元组的每个元素上的函数对象,并从中生成一个元组。
然后我们写dereference元组:
auto dereference_tuple = fmap_over_tuple(
[](auto&& e) { return *e; }
);
现在在C ++ 17中我们做到:
auto[Min, Max] = dereference_tuple( std::minmax_element(lhs.begin(), lhs.end() );
鲍勃是你的叔叔。
在C ++ 11中,只需执行您所做的操作。足够干净。