为何C++未提供返回可修改引用对的std::minmax函数？

这是个挺有意思的问题——为什么标准库的std::minmax不设计成返回引用对，而自己动手实现这类版本又会踩哪些坑？咱们一步步拆解来看：

一、为什么标准库std::minmax不返回引用对？ #

标准库的设计优先考虑安全性和通用性，核心原因有两个：

• 悬垂引用的致命风险：如果用户传入临时值（比如std::minmax(42, 100)），返回引用的话，这个引用会指向函数调用结束后就销毁的临时对象，后续使用会触发未定义行为（崩溃、乱值等）。标准库返回值副本的方式彻底避免了这个问题，哪怕参数是临时对象，返回的也是合法的独立值。
• 接口一致性：标准库中类似的工具函数（比如std::min、std::max）默认都返回值，保持统一的接口风格能降低用户的学习成本，减少误用概率。

二、你实现的返回引用版本存在哪些潜在问题？ #

你的实现通过common trait试图智能推导返回的引用类型（区分const/非const、左值/临时对象），在部分场景下能正常工作，但仍有不少容易忽略的隐患：

1. 临时对象导致的隐式悬垂引用 #

当传入两个临时对象时（比如minmax(int(1), int(10))），你的实现返回的pair<const int&, const int&>会指向这两个临时对象。虽然你测试里用auto const& small看起来能运行，但这是未定义行为：C++中只有直接绑定到临时对象的引用会延长其生命周期，而通过pair内部的引用间接绑定并不适用这个规则。临时对象在minmax函数返回后就会销毁，后续访问small就是访问已释放的内存，可能在不同编译器/环境下出现崩溃、乱值等问题。

2. 接口的“意外性” #

用户使用这个函数时，很容易忽略参数类型对返回值的影响：如果某次调用不小心传入了临时对象，却依然用非const引用接收返回值，轻则编译报错，重则运行时出问题。这种“依赖参数类型决定返回是否安全”的接口，比标准库“总是返回值”的接口更容易误用。

3. 类型推导的局限性 #

你的common trait虽然覆盖了不少场景，但仍有遗漏（比如不同类型的左值引用，比如int&和long&），这会导致某些合法调用无法通过编译，而标准库的std::minmax会通过隐式转换处理这类情况（返回转换后的副本）。

你的实现代码 #

#include<functional> // maybe all this options can be simplified
template<class T1, class T2>
struct common;
template<class T>
struct common<T, T>{using type = T;};
template<class T>
struct common<T const&, T&>{using type = T const&;};
template<class T>
struct common<T&, T const&>{using type = T const&;};
template<class T>
struct common<T, T&>{using type = T const&;};
template<class T>
struct common<T&, T>{using type = T const&;};
template<class T>
struct common<T const&, T>{using type = T const&;};
template<class T>
struct common<T, T const&>{using type = T const&;};
template<class T1, class T2, class Compare = std::less<>, class Ret = typename common<T1, T2>::type>
std::pair<Ret, Ret> minmax(T1&& a, T2&& b, Compare comp = {}){
 return comp(b, a) ? std::pair<Ret, Ret>(std::forward<T2>(b), std::forward<T1>(a))
 : std::pair<Ret, Ret>(std::forward<T1>(a), std::forward<T2>(b));
}

测试代码 #

#include<cassert>
int main(){
 { int a = 1; int b = 10;
 auto& small = minmax(a, b).first;
 assert(small == 1);
 small += 1;
 assert(a == 2); }
 { int const a = 1; int b = 10;
 auto& small = minmax(a, b).first;
 assert(small == 1);
 // small += 1; error small is const reference, because a was const }
 { int a = 1; int const b = 10;
 auto& small = minmax(a, b).first;
 assert(small == 1);
 // small += 1; error small is const reference, because a was const }
 { int const a = 1; int const b = 10;
 auto& small = minmax(a, b).first;
 assert(small == 1);
 // small += 1; error small is const reference, because a was const }
 { int b = 10;
 auto& small = minmax(int(1), b).first;
 assert(small == 1);
 // small += 1; error small is const reference, because first argument was const }
 { int a = 1;
 auto& small = minmax(a, int(10)).first;
 assert(small == 1);
 // small += 1; error small is const reference, because second argument was const }
 { int const a = 1;
 auto& small = minmax(a, int(10)).first;
 assert(small == 1);
 // small += 1; error small is const reference, because both arguments are const }
 { // auto& small = minmax(int(1), int(10)).first; // error, not clear why
 auto const& small = minmax(int(1), int(10)).first; // ok
 // auto small2 = minmax(int(1), int(10)).first; // also ok
 assert(small == 1);
 // small += 1; error small is const reference, because both arguments are const }
}

测试说明 #

传入可修改的左值引用时，返回的引用可以直接修改原变量；传入常量引用或临时对象时，返回常量引用，无法修改原对象（或临时对象已销毁，修改无意义）。

内容的提问来源于stack exchange，提问作者alfC