我正在编写一个网络库并大量使用移动语义来处理文件描述符的所有权。我的一个班级希望接收其他类型的文件描述符包装器并获得所有权，所以它类似于
struct OwnershipReceiver
{
template <typename T>
void receive_ownership(T&& t)
{
// taking file descriptor of t, and clear t
}
};
它必须处理多个不相关的类型，因此 receive_ownership 必须是一个模板，并且为了安全起见，我希望它只绑定到右值引用，以便用户在传递左值时必须显式声明 std::move 。
receive_ownership(std::move(some_lvalue));
但问题是：C++ 模板推导允许传入一个左值而不需要额外的努力。实际上，我不小心将一个左值传递给了receive_ownership，并在以后使用该左值（清除），实际上是我自己开枪打死了自己。
所以这里有一个问题：如何使模板只绑定到右值引用？
您可以限制T为不是左值引用，从而防止左值绑定到它：
#include <type_traits>
struct OwnershipReceiver
{
template <typename T,
class = typename std::enable_if
<
!std::is_lvalue_reference<T>::value
>::type
>
void receive_ownership(T&& t)
{
// taking file descriptor of t, and clear t
}
};
添加某种限制以T使其仅接受文件描述符包装器也可能是一个好主意。
一种简单的方法是提供一个接受左值引用的已删除成员：
template<typename T> void receive_ownership(T&) = delete;
这将始终是左值参数的更好匹配。
如果您有一个带有多个参数的函数，所有这些参数都需要是右值，我们将需要几个已删除的函数。在这种情况下，我们可能更喜欢使用 SFINAE 对任何左值参数隐藏函数。
一种方法是使用 C++17 和 Concepts TS：
#include <type_traits>
template<typename T>
void receive_ownership(T&& t)
requires !std::is_lvalue_reference<T>::value
{
// taking file descriptor of t, and clear t
}
或者
#include <type_traits>
void receive_ownership(auto&& t)
requires std::is_rvalue_reference<decltype(t)>::value
{
// taking file descriptor of t, and clear t
}
再进一步，您可以定义自己的新概念，如果您想重用它，或者只是为了更加清晰，这可能很有用：
#include <type_traits>
template<typename T>
concept bool rvalue = std::is_rvalue_reference<T&&>::value;
void receive_ownership(rvalue&& t)
{
// taking file descriptor of t, and clear t
}
注意：使用 GCC 6.1，您需要传递-fconcepts给编译器，因为它是 C++17 的扩展，而不是它的核心部分。
为了完整起见，这是我的简单测试：
#include <utility>
int main()
{
int a = 0;
receive_ownership(a); // error
receive_ownership(std::move(a)); // okay
const int b = 0;
receive_ownership(b); // error
receive_ownership(std::move(b)); // allowed - but unwise
}
我学到了一些似乎经常让人们感到困惑的东西：使用 SFINAE 是可以的，但我不能使用：
std::is_rvalue_reference<T>::value
它按我的意愿工作的唯一方法是
!std::is_lvalue_reference<T>::value
原因是：我需要我的函数来接收rvalue，而不是rvalue reference。有条件启用的函数std::is_rvalue_reference<T>::value不会接收右值，而是接收右值引用。
对于左值引用，T 被推断为左值引用，而对于右值引用，T 被推断为非引用。
因此，如果函数绑定到右值引用，编译器最后看到的特定类型 T 是：
std::is_rvalue_reference<T>::value
并不是
std::is_rvalue_reference<T&&>::value
不幸的是，如果您实际上是在尝试进行区分and的重载（例如在两者中使用，一个与另一个与） ，那么尝试is_rvalue_reference<TF>（完美转发类型在哪里）似乎效果不佳。TFconst T&T&&enable_ifis_rvalue_reference_v<TF>!is_rvalue_reference_V<TF>
一个解决方案（虽然很老套）是衰减 forwarded T，然后将重载放在知道这些类型的容器中。生成了这个例子：
呵呵，我错了，只是忘了看托比的答案（is_rvalue_reference<TF&&>）——虽然你可以这样做令人困惑std::forward<TF>(...)，但我想这就是为什么decltype(arg)也可以。
任何人，这是我用于调试的内容：（1）使用struct重载，（2）使用错误的检查is_rvalue_reference，以及（3）正确的检查：
/*
Output:
const T& (struct)
const T& (sfinae)
const T& (sfinae bad)
---
const T& (struct)
const T& (sfinae)
const T& (sfinae bad)
---
T&& (struct)
T&& (sfinae)
const T& (sfinae bad)
---
T&& (struct)
T&& (sfinae)
const T& (sfinae bad)
---
*/
#include <iostream>
#include <type_traits>
using namespace std;
struct Value {};
template <typename T>
struct greedy_struct {
static void run(const T&) {
cout << "const T& (struct)" << endl;
}
static void run(T&&) {
cout << "T&& (struct)" << endl;
}
};
// Per Toby's answer.
template <typename T>
void greedy_sfinae(const T&) {
cout << "const T& (sfinae)" << endl;
}
template <
typename T,
typename = std::enable_if_t<std::is_rvalue_reference<T&&>::value>>
void greedy_sfinae(T&&) {
cout << "T&& (sfinae)" << endl;
}
// Bad.
template <typename T>
void greedy_sfinae_bad(const T&) {
cout << "const T& (sfinae bad)" << endl;
}
template <
typename T,
typename = std::enable_if_t<std::is_rvalue_reference<T>::value>>
void greedy_sfinae_bad(T&&) {
cout << "T&& (sfinae bad)" << endl;
}
template <typename TF>
void greedy(TF&& value) {
using T = std::decay_t<TF>;
greedy_struct<T>::run(std::forward<TF>(value));
greedy_sfinae(std::forward<TF>(value));
greedy_sfinae_bad(std::forward<TF>(value));
cout << "---" << endl;
}
int main() {
Value x;
const Value y;
greedy(x);
greedy(y);
greedy(Value{});
greedy(std::move(x));
return 0;
}