C++ 不同的 minmax 实现

Question

因为您可能(不知道)使用 std::minmax使用 auto 和 temporary 参数可能很危险。例如以下代码是 UB 因为 std::minmax返回引用对，而不是值:

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

我想问一下有没有可能制作std::minmax函数在没有任何开销的情况下安全地或至少更安全地运行？我想出了这样的解决方案，但我不完全确定它是否等同于当前的 minmax因为生成的程序集对于类似 STL 的实现和我的是不同的。所以问题是:我实现 minmax 的可能问题/缺点是什么？关于 std -像一个:

//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));
}

Live demo at godbolt.org

---

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

Answer 1

我不太清楚你想要达到什么目的。你写道:

without any overhead

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

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

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. a (const) lvalue reference 到相应的函数参数，如果它是 lvalue，

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&> .

因此，结果类型将取决于运行时条件(通常需要运行时多态性)。

---

更新

出于好奇，我想出了一个包装器，它可以通过(const)指针或值来容纳一些对象:

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 的左值和右值参数进行复制.