从算术运算符返回时，为什么不能将此类作为引用传递？

Question

If I have a simple class like this:

template<typename T>
class coord
{
public:

    coord() : x(0), y(0)
    {
    }

    coord(T X, T Y) : x(X), y(Y)
    {
    }

    T x;
    T y;

    coord& operator-=(const coord& rhs)
    {
        (*this).x -= rhs.x;
        (*this).y -= rhs.y;
        return *this;
    }

    coord& operator+=(const coord& rhs)
    {
        (*this).x += rhs.x;
        (*this).y += rhs.y;
        return *this;
    }
};

Along with the following operators (they're not friend s because there's no private members to access).

template<typename T = int>
inline coord<T> operator-(coord<T> lhs, const coord<T>& rhs)
{
    lhs -= rhs;
    return lhs;
}

template<typename T = int>
inline coord<T> operator+(coord<T> lhs, const coord<T>& rhs)
{
    lhs += rhs;
    return lhs;
}

Elsewhere in my code I have another class A with a method that looks like this:

void A::SetVarC(coord<int>& c)
{
    m_c = c;
}

(assume there's a getter for m_c as well)

When I try to invoke this method using the addition and subtraction operators I overloaded:

int x = 1;
int y = 1;

A* a = new A();

coord c1(1,2);

a->SetVarC(c1 - a->GetVarC() + coord<int>(x,y));

I get an error that there's no known conversion from coord<int> to coord<int>& . I can see that my subtraction and addition operators aren't returning references, but I thought that wouldn't matter. I am using C++11... are move semantics coming into play here?

Answer 1

Temporary cannot be bind to non const reference, change SetVarC to

void A::SetVarC(const coord<int>& c)
{
    m_c = c;
}

or

void A::SetVarC(coord<int> c)
{
    m_c = std::move(c);
}

Answer 2

You are passing a temporary coord<int> object to A::SetVarC() which requires a non-const reference, which is not possible.

You should fix your code by changing A::SetVarC() to accept a const coord<int>& .

Answer 3

You're creating arithmetic operators with a side affect... These operators shouldn't change the value of the arguments used.

And, to the answer your question, these methods return a temporary object, that can't be passed as reference to SetVarC .

template<typename T = int>
inline coord<T> operator-(const coord<T>& lhs, const coord<T>& rhs)
{
    coord<T> res(lhs)
    res -= rhs;
    return res;
}

template<typename T = int>
inline coord<T> operator+(const coord<T>& lhs, const coord<T>& rhs)
{
    coord<T> res(lhs)
    res += rhs;
    return res;
}