参数类型推导、引用和右值

Question

考虑以下情况：函数模板需要转发参数同时保持它的左值性，以防它是非 const 左值，但它本身与参数实际是什么无关，如下所示：

template <typename T>
void target(T&) {
    cout << "non-const lvalue";
}

template <typename T>
void target(const T&) {
    cout << "const lvalue or rvalue";
}


template <typename T>
void forward(T& x) {
    target(x);
}

当x 是右值时，而不是将T 推导出为常量类型，它会报错：

int x = 0;
const int y = 0;

forward(x); // T = int
forward(y); // T = const int
forward(0); // Hopefully, T = const int, but actually an error
forward<const int>(0); // Works, T = const int

似乎forward 处理右值（不调用显式模板参数）需要有一个forward(const T&) 重载，即使它的主体是完全重复的。

有什么办法可以避免这种重复吗？

Answer 1

这是一个已知问题，也是 C++0x 中右值引用的目的。该问题在 C++03 中没有通用解决方案。

发生这种情况有一些古老的历史原因，这是非常没有意义的。我记得问过一次，答案让我很沮丧。

Answer 2

一般来说，模板的这个讨厌的问题应该需要重复，因为变量是否为 const 或不是引用的语义是完全不同的。

对此的 C++11 解决方案是“decltype”，但这是一个坏主意，因为它所做的只是复合且已经损坏的类型系统。

无论标准或委员会怎么说，“const int”都不是也永远不会是类型。 “int&”也不会是一种类型。因此，不应允许模板中的类型参数绑定到此类非类型，谢天谢地，情况就是这样。不幸的是，您仍然可以明确强制这种无原则的替换。

有一些愚蠢的规则试图“解决”这个问题，例如“const const int”减少到“const int”，我什至不确定如果你得到“int & &”会发生什么：记住标准不将“int&”算作一种类型，有一个“int lvalue”类型，但这是不同的：

int x;       // type is lvalue int
int &y = x;  // type is lvalue int

这个问题的正确解决方案其实很简单：一切都是可变对象。扔掉“const”（它没那么有用）并扔掉引用、左值和右值。很明显，所有类类型都是可寻址的，无论是否右值（“this”指针就是地址）。委员会试图禁止分配和寻址右值是徒劳的。寻址案例有效，但很容易用微不足道的演员表逃脱。赋值的情况根本不起作用（因为赋值是一个成员函数并且右值是非常量的，你总是可以赋值给一个类型为右值的类）。

无论如何，模板元编程人群都有“decltype”，通过它您可以找到包含任何“const”和“&”位的声明的编码，然后您可以使用各种库运算符分解该编码。以前无法做到这一点，因为该信息实际上不是类型信息（“ref”实际上是存储分配信息）。

Answer 3

当x 是右值时

但x 永远不是右值，因为名称是左值。

有没有办法避免这种重复？

C++0x 中有一个方法：

#include <utility>

template <typename T>
void forward(T&& x)   // note the two ampersands
{
    target(std::forward<T>(x));
}

由于引用折叠规则，表达式std::forward<T>(x) 与您自己的转发函数的参数具有相同的值类别。

Answer 4

假设有 k 个参数，据我了解，C++03 中唯一的“解决方案”是手动写出 2^k 个转发函数，采用 & 和 const& 参数的所有可能组合。为了说明，假设target() 实际上采用了 2 个参数。然后你需要：

template <typename T>
void forward2(T& x, T& y) {
    target(x, y);
}

template <typename T>
void forward2(T& x, T const& y) {
    target(x, y);
}

template <typename T>
void forward2(T const& x, T& y) {
    target(x, y);
}

template <typename T>
void forward2(T const& x, T const& y) {
    target(x, y);
}

显然，对于较大的 k，这变得非常笨拙，因此正如其他答案所提到的，C++0x 中的右值引用。