作为成员函数两次重载*乘法运算符？

Question

Scroll down for TL:DR.

This question is similar to this one, but has some differences. It concerns overloading the * operator twice for a class called jVector , which simply represents a two-dimensional cartesian vector.

The first type of multiplication is jVector * jVector , or a dot product . The second type is multiplication by a real number, double * jVector . This simply returns a vector with its entries multiplied by the double.

Here is some code to illustrate what I'm trying to do:

class jVector{
    public:
        double x, y;

        jVector(double x_val = 0., double y_val = 0.){
            x = x_val;
            y = y_val;
        }

        //Operator overload functions
        //[...]

        //F1: Dot product (WORKS)
        double operator* (jVector& factor){
            double result;
            result = x * factor.x;
            result += y * factor.y;
            return result;
        }

        //F2: Real number multiplication (DOES NOT WORK)
        jVector operator* (double f){
            jVector result;
            result.x = x * f;
            result.y = y * f;
            return result;
        }

        //[...]
}

//F3: As a non-member (WORKS)
jVector operator* (double f, jVector V){
    jVector result;
    result.x = V.x * f;
    result.y = V.y * f;
    return result;
}

The three relevant functions are marked F1 , F2 and F3 . The functions F2 and F3 are never defined at the same time (I comment out one of them to test the other).

Here is the result of trying to express something like 2.0 * Foo , where Foo is a vector of type jVector . The operation works as expected when using F3 , the function which is defined outside the class. However, when using only F2 , the member function, an error is raised which says no match for 'operator*' in '2 * Foo' .

This is the same type of error which you get if you don't overload an operator at all, suggesting that I didn't define F2 properly, or F2 is conflicting with F1 .

I'm fairly certain my problem is different from the one in the question I mentioned earlier, since F1 and F2 have different return types and argument types.

TL:DR

So here's my question: why am I able to overload * twice, only as long as one of them is defined as a non-member function? Why can't both overload functions be members of the class?

Answer 1

For member function operator overloads, the first operand must be an object of the class. The parameter of the overloaded function is the second operand. So:

double operator* (double f){

only applies to the case where you are doing a_vector * a_double , and not to a_double * a_vector .

For this reason (and others) it's generally better to use non-member functions for overloaded operators. The way I would suggest doing it is:

// member function
jVector & jVector::operator*=( double f )
{
    x *= f;
    y *= f;
    return *this;
}

// free functions
jVector operator* (double f, jVector V) { return V *= f; }
jVector operator* (jVector V, double f) { return V *= f; }

Answer 2

It doesn't work as a member function because your F2 alternative takes a jVector as the first operand ALWAYS (it is a member function, so you don't have a choice of what the first argument is - it is jVector *this [hidden by the language]). The compiler could in theory allow the two operands to swap place (it could for x * 2.0 convert to 2.0 * x for regular math operations, but since operator overloads aren't made to be "swapped around", that wouldn't be very good if the compiler DID re-arrange them)

For the first operand to be double , you need a freestanding function.