get know whether 'this' or other arguments are rvalue

Question

Suppose we have class Base and its member function Base doSomething(const Base& other). I would like to know how to determine whether this or other object is rvalue, for example I need something like

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

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

I know that possible solution is to use templated friend function:

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);
    }
}

however this approach would be highly undesirable in my case

Thanks in advance !

Answer 1

You can do this using a 4 overloads:

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
}

If you want to be able to accept const Base's then you can make these templates and use SFINAE to make sure the decayed template type is a Base like

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
}

---

Another way to do this is with just two overloads and forwarding references. Then you can check if the type of the parameter is an lvalue reference to determine if you have an lvalue or rvalue. This works when you use forwarding references since the type of the template parameter is deduced to be T& instead of T if it was an rvalue. That would give you code like

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
}

And then if you need to you can constrain the template by adding

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

To the template parameters to constrain the template to the types you want for the parameters.

to each of

Answer 2

This is how you discriminate between lvalue this and rvalue this:

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

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

This is how you discriminate between lvalue inputs and rvalue inputs, generally:

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

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

It sounds like you wanted some combination of the two, so perhaps:

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

This strikes me as kind of strange, though. Consider whether you're really going down the proper path.

Answer 3

From https://en.cppreference.com/w/cpp/language/member_functions

A non-static member function can be declared with no ref-qualifier, with an lvalue ref-qualifier (the token & after the parameter list) or the rvalue ref-qualifier (the token && after the parameter list). During overload resolution, non-static cv-qualified member function of class X is treated as follows:

• no ref-qualifier: the implicit object parameter has type lvalue reference to cv-qualified X and is additionally allowed to bind rvalue implied object argument
• lvalue ref-qualifier: the implicit object parameter has type lvalue reference to cv-qualified X
• rvalue ref-qualifier: the implicit object parameter has type rvalue reference to cv-qualified X

So, if you do:

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

This function will be called for this 'rvalued'