了解“this”或其他参数是否为右值

Question

假设我们有 Base 类及其成员函数 Base doSomething(const Base& other)。 我想知道如何确定这个或其他对象是否是右值， 例如我需要类似的东西

Base Base::doSomething(const Base& other) {

    ...
    if(this_is_rvalue) {
        // use resources of *this
    }
    else if(other_is_rvalue) {
        // use resources of other
    }
    ...
}

我知道可能的解决方案是使用模板化朋友功能：

template<typename T1, typename T2, typename = typename std::enable_if<.....>::type>
friend Base doSomething(T1&& this_, T2&& other) {

    ...
    if(std::is_rvalue_reference<T1&&>::value) {
        // use resources of this_
        return std::move(this_);
    }
    else if(std::is_rvalue_reference<T2&&>::value) {
        // use resources of other
        return std::move(other);
    }
}

但是在我的情况下这种方法是非常不可取的

提前致谢！

Answer 1

您可以使用 4 个重载来做到这一点：

Base Base::doSomething(Base& other) && {
     // *this is an rvalue and other is an lvalue
}

Base Base::doSomething(Base&& other) && {
    // *this and other are rvalues
}

Base Base::doSomething(Base& other) & {
    // *this and other are lvalues
}

Base Base::doSomething(Base&& other) & {
    // *this is an lvalue and other is an rvalue
}

如果您希望能够接受const Base，那么您可以制作这些模板并使用SFINAE 来确保衰减的模板类型是Base 之类的

template <typename T, std::enable_if_t<std::is_same_v<std::decay_t<T>, Base>, bool> = true>
Base Base::doSomething(T& other) && {
     // *this is an rvalue and other is an lvalue
}

Base Base::doSomething(Base&& other) && {
    // *this and other are rvalues
}

template <typename T, std::enable_if_t<std::is_same_v<std::decay_t<T>, Base>, bool> = true>
Base Base::doSomething(T& other) & {
    // *this and other are lvalues
}

Base Base::doSomething(Base&& other) & {
    // *this is an lvalue and other is an rvalue
}

---

另一种方法是只使用两个重载和转发引用。然后您可以检查参数的类型是否为左值引用以确定您是否具有左值或右值。这在您使用转发引用时有效，因为模板参数的类型推断为T&，而不是T（如果它是右值）。这会给你类似的代码

template<typename A, typename B, typename C>
Base Base::doSomething(A&& other1, B&& other2, C&& other3) &
{
    // this is always an lvalue in this function
    if (std::is_lvalue_reference_v<A>)
        // other1 is an lvalue
    else
        // other1 is a rvalue
    if (std::is_lvalue_reference_v<B>)
        // other2 is an lvalue
    else
        // other2 is a rvalue
    if (std::is_lvalue_reference_v<C>)
        // other3 is an lvalue
    else
        // other3 is a rvalue
}

template<typename A, typename B, typename C>
Base Base::doSomething(A&& other1, B&& other2, C&& other3) &&
{
    // this is always an rvalue in this function
    if (std::is_lvalue_reference_v<A>)
        // other1 is an lvalue
    else
        // other1 is a rvalue
    if (std::is_lvalue_reference_v<B>)
        // other2 is an lvalue
    else
        // other2 is a rvalue
    if (std::is_lvalue_reference_v<C>)
        // other3 is an lvalue
    else
        // other3 is a rvalue
}

如果你需要，你可以通过添加来约束模板

std::enable_if_t<std::is_same_v<std::decay_t<A>, type_for_other1>, 
                 std::is_same_v<std::decay_t<B>, type_for_other2>,
                 std::is_same_v<std::decay_t<B>, type_for_other3>, bool> = true

到模板参数以将模板约束为您想要的参数类型。

给每个人

Answer 2

这就是你区分左值this和右值this的方式：

Base Base::doSomething(const Base& other) const &
//                                        ^^^^^^^ lvalue only

Base Base::doSomething(const Base& other) &&
//                                        ^^ rvalue only

这就是您区分左值输入和右值输入的方式，通常：

Base Base::doSomething(const Base& other) {
     // use resources of *this
}

Base Base::doSomething(Base&& other) {
    // use resources of other
}

听起来你想要两者的某种组合，所以也许：

Base Base::doSomething(Base&&) const &;
Base Base::doSomething(const Base&) &&;

不过，这让我觉得有点奇怪。考虑一下你是否真的走上了正确的道路。

Answer 3

来自https://en.cppreference.com/w/cpp/language/member_functions

一个非静态成员函数可以在没有引用限定符的情况下声明，可以使用左值引用限定符（参数列表后面的标记 &）或右值引用限定符（参数列表后面的标记 &&）。在重载决议期间，类 X 的非静态 cv 限定成员函数被处理如下：

• 没有引用限定符：隐式对象参数具有对 cv 限定 X 的左值引用类型，并且还允许绑定右值隐含对象参数
• lvalue ref-qualifier：隐式对象参数的类型为 cv-qualified X 的左值引用
• rvalue ref-qualifier：隐式对象参数的类型为 cv-qualified X 的右值引用

所以，如果你这样做：

Base Base::doSomething(const Base& other) &&;

将为this'rvalued'调用此函数