Overloading + with a member function...

[kekie]

So, take the following;

template<typename type, typename type2>
double add(type x,type2 y)
{
    return x+y;
}


class TrivialInt
{
public:
    int m_value;
    TrivialInt(int input = 0):m_value(input)
    {
        //
    }
    double operator+(double inValue)
    {
        return inValue+m_value;
    }
};

int main()
{
    TrivialInt instance(3);
    cout<<add(instance,2.3);
    return 0;
}

This prints the expected '5.3'.

But, if I reverse add(instance,2.3) to add(2.3,instance), then I get an error, because it doesn't know what to do with int+TrivialInt only the other way around. (TrivialInt+int)

I could fix this with friend functions (programming for both contingencies);

template<typename type, typename type2>
double add(type x,type2 y)
{
    return x+y;
}


class TrivialInt
{
public:
    int m_value;
    TrivialInt(int input = 0):m_value(input)
    {
        //
    }
    friend double operator+(double inValue,TrivialInt& inTrivial);
    friend double operator+(TrivialInt& inTrivial,double inValue);
};


double operator+(double inValue,TrivialInt& inTrivial)
{
    return inTrivial.m_value + inValue;
}
double operator+(TrivialInt& inTrivial,double inValue)
{
    return inTrivial.m_value + inValue;
}


int main()
{
    TrivialInt instance(3);
    cout<<add(2.3,instance)<<"\n";
    cout<<add(instance,2.3);
    return 0;
}

So my question is really 'can I do this with a member function'?

[Yanson]

The short answer is no.

To call a member of a class, you need an object of that class. When dealing with binary operators the object of the class is always the left hand operand.

ie

TrivialInt instance(3);
     instance + 2.3;

2.3 + instance // this is illegal

[kekie]

Thanks!