C++ 如何定义一个只绑定xvalue或prvalue而不绑定两者的函数

有没有办法定义一个只处理xvalue或prvalue的函数（或者这里是异或）

例如，假设我有一个方法

f（foo&&f）

，我如何声明

f

来绑定xvalue类型并拒绝prvalue类型，反之亦然

struct Foo{};
void xvalue(/*what put here ?*/){}
void prvalue(/*what put here ?*/){}

void main()
{
  Foo foo;

  prvalue(Foo());//compile
  prvalue(std::move(foo)));//fail at compilation

  xvalue(std::move(foo)); //compile
  xvalue(Foo());//fail at compilation
}

可能通过使用

std:：enable_if

以及decltype（e）是xvalues的右值引用类型而不是prvalue的非引用类型这一事实来实现？

使用此代码应该很简单

#include <type_traits>
#include <iostream>
#include <utility>

template <typename T>
bool is_xvalue()
{
    if (std::is_lvalue_reference<T>::value)
        return false;
    else if (std::is_rvalue_reference<T>::value)
        return true;
    return false;
}

template <typename T>
bool is_prvalue()
{
    if (std::is_lvalue_reference<T>::value)
        return false;
    else if (std::is_rvalue_reference<T>::value)
        return false;
    else
        return true;
    return false;
}

struct Foo {};

int main()
{
    std::cout << std::boolalpha;
    std::cout << is_prvalue<decltype(Foo())>() << "\n"; // true
    std::cout << is_prvalue<decltype(std::move(Foo()))>() << "\n"; // false
    std::cout << is_xvalue<decltype(Foo())>() << "\n"; // false
    std::cout << is_xvalue<decltype(std::move(Foo()))>() << "\n"; // true
    return 0;
}

#包括
#包括
#包括
模板
bool是_xvalue（）
{
if（std:：is_lvalue_reference:：value）
返回false；
else if（std:：is\u rvalue\u reference:：value）
返回true；
返回false；
}
模板
bool是_prvalue（）
{
if（std:：is_lvalue_reference:：value）
返回false；
else if（std:：is\u rvalue\u reference:：value）
返回false；
其他的
返回true；
返回false；
}
结构Foo{}；
int main（）
{
std：：cout这不是它应该做的吗？对你的
f
的什么调用目前正在编译，没有你想要拒绝的问题？@hvd：据我所知，
f（foo&&f）
可以接受xvalue和prvalue，但不仅仅是接受xvalue和拒绝prvalue，反之亦然。我可能会笨拙地问，显然是这样。
f（foo&&f）
只绑定到xvalues或prvalues，因此根据您问题中的措辞，它似乎正是您想要的。您编辑的评论澄清了很多。@hvd：我编辑了我的问题，以澄清我对整洁问题的要求+1，但我很好奇：这有什么实际用途？演绎导致
Foo&
p完美地匹配
T&&
，给出
T=Foo
，与prvalue得出的结果相同。@Xeo那么这是不可能的吗？使用演绎法？我认为是的。我认为这些函数必须是
constepr
（或元函数），否则您不应该在非类型模板参数中使用它们。
struct Foo {};

template <typename T, typename = typename std::enable_if<is_prvalue<T>(), void>::type>
void prvalue(T&& t)
{
}

template <typename T, typename = typename std::enable_if<is_xvalue<T>(), void>::type>
void xvalue(T&& t)
{
}

prvalue<decltype(Foo())>(Foo());
// prvalue<decltype(std::move(Foo()))>(std::move(Foo())); - compile error
xvalue<decltype(std::move(Foo()))>(std::move(Foo()));
// xvalue<decltype(Foo())>(Foo()); - compile error