为什么这个 cpp-next 的“最小”模板有问题？

Question

我正在阅读 cpp-next，其中这个 min 模板是作为如何将冗长的 C++ 代码与 python 代码进行比较的示例

template <class T, class U>
auto min(T x, U y)->decltype(x < y ? x : y)
{ return x < y ? x : y; }

起初这看起来很无辜，但 Daveed Vandevoorde 说了这句话

在其返回类型规范中使用 decltype 的 min 模板不起作用：它返回一个引用（因为参数是一个左值），该引用最终在最常见的用途中引用了一个局部变量。

我认为每个人可能都不清楚问题是如何表现出来的。能否给个详细的解释和可能的修复方法？

Answer 1

问题是参数没有被当作引用。在多态类型的情况下，这会调用切片，然后引用返回到局部变量。解决方案是将参数作为右值引用，调用完美转发，然后简单地推导并返回返回类型。完成后，返回一个引用就可以了，因为该值仍然存在。

Answer 2

第 3 版：康拉德鲁道夫

template <class T, class U>
auto min(T x, U y) -> typename std::remove_reference<decltype(x < y ? x : y)>::type
{ 
    return x < y ? x : y; 
}

第 2 版：KennyTM

template <class T, class U>
auto min(T x, U y)->decltype(x < y ? std::declval<T>() : std::declval<U>())
{ 
    return x < y ? x : y; 
}

rev 1: T 和 U 必须是默认可构造的

template <class T, class U>
auto min(T x, U y)->decltype(x < y ? T() : U())
{ 
    return x < y ? x : y; 
}

测试：

int main()
{
   int x; int y;
   static_assert(std::is_same<decltype(min(x, y)), int>::value, "");
   return 0;
}

编辑：

我有点惊讶，但它实际上是用 remove_reference 编译的。

Answer 3

参数是按值传递的（T 和 U 推导出为 int），但在这种情况下，?: 表达式的类型被推导出为引用，因为它们是函数内部的本地左值。 @Johannes 的答案将在几分钟后提供。 :D

Answer 4

有什么大惊小怪的，为什么没有人尝试显而易见的解决方案，即完美转发？

template <class T, class U>
typename std::enable_if< ! std::is_integral< T >() || ! std::is_integral< U >(),
                         typename std::common_type< T, U >::type >::type
min(T &&x, U &&y)
    { return x < y ? std::forward< T >( x ) : std::forward< U >( y ); }

template <class T, class U>
decltype( typename std::enable_if< std::is_integral< T >() && std::is_integral< U >(),
                         decltype( typename std::common_type< T, U >
         ::type{ U( -1 ) } ) >::type{ T( -1 ) } )
min(T &&x, U &&y)
    { return x < y ? std::forward< T >( x ) : std::forward< U >( y ); }

现在它就像您将表达式放在调用函数中一样工作，这正是用户所期望的（并且只是整体上最好的）。

编辑：现在它禁止危险的无符号与有符号操作，根据霍华德的论文，如果两个操作数都是整数类型，则要求从每个操作数类型到结果类型的转换是非窄化的.然而，GCC 不会编译这个，抱怨“sorry, unimplemented: mangling constructor”。如果在函数签名中以任何方式使用统一初始化，这似乎会发生。

Answer 5

通过引用返回有时可能是一项功能，而不是错误。我们稍后会回到这个。首先回顾一下基础知识：

int x; int y;
x    // this is an lvalue
y    // lvalue also
x+y  // not an lvalue - you couldn't do (x+y) = 3
x<y?x:y // lvalue - you can do (x<y?x:y) = 0

最后一行显示?: 通常可以是左值。即您可以使用(x<y?x:y)=0 将最小的变量设置为 0，而不要理会另一个变量。当然，你不能做(1<3?6:8)=0，因为你不能做6=0 或8=0。所以在这种情况下它只是一个右值。

在 min 中，x 和 y 是函数参数的名称，因此是左值。 decltype(x<y?:x:y) 是 int&。 （我发现this other cpp-Next article 也很有用。）

那么为什么这会是个问题呢？好吧，如果min 的返回类型是引用，那么它将返回对函数参数x 或y 之一的引用。现在的问题是，x 和 y 是否引用了自己？

考虑这个用例：

int m = 5; int n = 10;
min(m,n) = 0; // do you want this to work?

我们要做出决定。也许我们希望 min 返回引用，如果 min 的参数是引用。我想这有点品味问题。如果您只想返回非引用，这很容易在decltype(x<y?x:y) 周围使用std::remove_reference 来执行。但这很无聊。让我们允许自己（有时）返回引用；在许多情况下，它可能会更有效和有用。

如果您使用 min 的原始示例定义以及 x 或 y 的非引用类型，则 min 将在其参数中返回对本地值的引用。这很糟糕，因为引用将无效并且行为未定义。例如，这会很糟糕：

int p = min(5,8); // reading from a now-invalid reference.

因此，我们必须通过各种用例并决定我们想要什么行为：

// Desired behaviour
int m = 5;
int n = 10;
min(3,7); // return by value. i.e. return an int
min(m,n); // return an int& which maps to either m or n
min(3,n); // return by value
min(foo(), bar()) // what makes sense here?

我们是否都同意我们希望这样一个min 的行为？那么，我们如何实现呢？