CODEWITHSUNDEEP
c++operator-overloadingrvalue-referenceunary-operator
Anon
Anon

Reputation: 155

C++ is it possible to overload the unary minus operator of an rvalue reference?

is it possible to discern between these two methods? should one not mutate an rvalue when in this case seems perfectly reusable?

TYPE a;
TYPE b = -a;      // unary operator- of a TYPE& aka lvalue ref
TYPE c = -(a+b);  // unary operator- of a TYPE&& aka rvalue ref

Upvotes: 14

Views: 1282

Answers (2)

marcinj
marcinj

Reputation: 50026

You can use reference qualifier-s (or ref-qualifiers as in standard)

http://coliru.stacked-crooked.com/a/40905649dc0c14e7

example:

#include <iostream>
#include <string>
#include <vector>

class X
{
   public:
      int n;
      X(const X&) = default;
      X() : n(0) {}
      X(int n) : n(n) {}

      X operator- () const &  // lvalue ref-qualifier
      {
         std::cout << "&\n";
         X x(-n);
         return x;
      }

      X operator- () const && // rvalue ref-qualifier
      {
         std::cout << "&&\n";
         X x(-n);
         return x;
      }    

      friend X operator+(const X& lhs, const X& rhs) {
          return X(lhs.n + rhs.n);
      }
};

int main()
{
    X a;
    X b = -a;      // unary operator- of a TYPE& aka lvalue ref
    X c = -(a+b);
}

outputs:

&
&&

Upvotes: 15

Jarod42
Jarod42

Reputation: 218035

Something like:

class Type
{
public:
    Type& operator -() && { std::cout << "rvalue\n";  return *this; }
    Type& operator -() & { std::cout << "lvalue\n";  return *this; }
};

Demo

Upvotes: 12

Related Questions