C++不同的最小最大值实现

C++ different minmax implementation

本文关键字：最大值 实现 C++      更新时间：2023-10-16

您可能(不知道(知道将std::minmax与自动和临时参数一起使用可能会很危险。例如，下面的代码是UB，因为std::minmax返回引用对，而不是值：

auto fun(){
auto res = std::minmax(3, 4);
return res.first;
}

我想问一下，是否有可能使std::minmax功能安全运行或至少更安全，没有任何开销？我想出了这样的解决方案，但我不完全确定它是否等同于当前minmax因为生成的程序集对于类似 stl 的实现和我的是不同的。所以问题是：与类似stdminmax相关的实现可能存在的问题/缺点是什么：

//below is std-like minmax
template< class T > 
constexpr std::pair<const T&,const T&> std_minmax( const T& a, const T& b ){
return (b < a) ? std::pair<const T&, const T&>(b, a)
: std::pair<const T&, const T&>(a, b);
}
//below is my minmax implementation
template< class T > 
constexpr std::pair<T, T> my_minmax( T&& a, T&& b ){
return (b < a) ? std::pair<T, T>(std::forward<T>(b), std::forward<T>(a))
: std::pair<T, T>(std::forward<T>(a), std::forward<T>(b));
}

godbolt.org 现场演示

正如你们中的一些人声称不清楚我在问什么，我想改写一下我想要的东西。我想编写与std::minmax完全相同的函数，但如果给定一个临时值 - 返回std::pair<T, T>而不是std::pair<const T &, const T &>。其次，在这样做时，我希望避免任何不必要的移动、复制数据等。

我不确定你想实现什么。你写道：

没有任何开销

但是您的解决方案将复制左值参数。这是你想要的吗？

无论如何，您不能以这种方式使用具有相同模板参数的两个转发引用，因为如果两个函数参数具有不同的类别，它将失败：

template <typename T> void f(T&& a, T&& b) { }
int main() {
int a = 3;
f(a, 1);  // error: template argument deduction/substitution failed
}

对于第一个函数参数，T将推导为int&，第二个参数推导为int。

如果要删除任何复制，唯一的可能性是生成的pair的成员为：

  1. 对相应函数参数的(常量(左值引用，如果它是左值，

  2. 从该参数移动的值，如果它是右值。

我认为这是不可能的。考虑：

std::string a("hello");
auto p = minmax(a, std::string("world"));

此处生成的类型将为std::pair<std::string&, std::string>。但是，在以下情况下

auto p = minmax(a, std::string("earth"));

生成的类型将不同，即std::pair<std::string, std::string&>.

因此，生成的类型将取决于运行时条件(通常需要运行时多态性(。

更新

出于好奇，我只是想出了一个包装器，可以通过(常量(指针或值来容纳一些对象：

template <typename T>
class val_or_ptr {
std::variant<T, const T*> v_;
public:
val_or_ptr(const T& arg) : v_(&arg) { }
val_or_ptr(T&& arg) : v_(std::move(arg)) { }
const T& get() const { return v_.index() ? *std::get<const T*>(v_) : std::get<T>(v_); }
};

这样，您可以将minmax定义为：

template <typename T, typename U,
typename V = std::enable_if_t<std::is_same_v<std::decay_t<T>, std::decay_t<U>>, std::decay_t<T>>>
std::pair<val_or_ptr<V>, val_or_ptr<V>> minmax(T&& a, U&& b) {
if (b < a) return { std::forward<U>(b), std::forward<T>(a) };
else return { std::forward<T>(a), std::forward<U>(b) };
}

现场演示在这里： https://wandbox.org/permlink/N3kdI4hzllBGFWVH

这是非常基本的实现，但它应该防止从minmax的左值和右值参数复制。

一种解决方案是当T是 r 值引用时，复制它而不是返回 r 值引用：

#include <utility>
template<class T>
std::pair<T, T> minmax(T&& a, T&& b) {
if(a < b)
return {a, b};
return {b, a};
}

当参数是 r 值引用时T被推导为非引用类型：

int main() {
int a = 1;
int const b = 2;
minmax(1, 1); // std::pair<int, int>
minmax(a, a); // std::pair<int&, int&>
minmax(b, b); // std::pair<const int&, const int&>
}

有了C++17，可以使用constexpr if来绑定左值参数并复制其他所有内容。有了C++11我可能会三思而后行，然后再为这样一个简单的用例构建一个尖括号，看起来很可怕。

戈德博尔特，科里鲁

template <typename T>
decltype(auto) minmax(T&& x, T&& y)
{
if constexpr(std::is_lvalue_reference_v<decltype(x)>)
return std::minmax(std::forward<T>(x), std::forward<T>(y));
else {
auto const res = std::minmax(x, y);
return std::make_pair(res.first, res.second);
}
}

为了支持混合 l/r 值，您可能需要两个模板参数，if/else 中有 4 个情况，std::cref(res.xxx)作为部分 std：：make_pair 的参数。

相关文章：