Error in overloading operator *

Question

I've a little problem with the overloading of an operator. I've a class named AtmospheridData, in which I define the operator *.

In the header I define this method inside the class:

//! Operator * (scalar)
AtmosphericData operator*(const qreal& qrMult) const;

and the definition, in the .cpp file, is the following:

AtmosphericData AtmosphericData::operator*(const qreal& qrMult) const
{
    AtmosphericData xResult;

    xResult.m_qrTemperature        = this->m_qrTemperature * qrMult;
    xResult.m_qrPressure           = this->m_qrPressure * qrMult;
    xResult.m_qrDensity            = this->m_qrDensity * qrMult;
    xResult.m_qrAbsoluteHumidity   = this->m_qrAbsoluteHumidity * qrMult;
    xResult.m_qrVisibility         = this->m_qrVisibility * qrMult;
    xResult.m_qrPrecipitationIndex = this->m_qrPrecipitationIndex * qrMult;
    xResult.m_xWind.qrNS           = this->m_xWind.qrNS * qrMult;
    xResult.m_xWind.qrEW           = this->m_xWind.qrEW * qrMult;
    xResult.m_xWind.qrVert         = this->m_xWind.qrVert * qrMult;

     xResult.m_xPrecipitationType = this->m_xPrecipitationType;

     return xResult;
}

Then, I use the class in the following expression:

AtmosphericData c2;
AtmosphericData t1;
AtmosphericData t2;
AtmosphericData y0;
AtmosphericData y1;
qreal           hx;

/* other code */

c2 = - (3 * (y0 - y1) + (hx * ((2 * t1) + t2))) / (hx * hx);

When I compile (using qmake-gcc under linux) I obtain the following error

error: no match for ‘operator*’ in ‘3 * AtmosphericData::operator-(const AtmosphericData&) const(((const AtmosphericData&)((const AtmosphericData*)(& y1))))’

I seems that I'm doing something wrong with the operator * declaration, but I don't understand what I am doing wrong.

Can anyone tell me how I can correct this error?

Thanks for your replies.

since you are declaring the operator in the class definition, are you sure you made it public? — Chad, Sep 02 '11 at 14:44
Yes, but now I've added the multiplication override with exchanged order between the qreal argument and the atmosphericdata one and it seem to work. — jepessen, Sep 02 '11 at 15:00

score 4 · Answer 1 · edited May 23 '17 at 11:47

Arithmetic operators in C++ are not automatically commutative, thus your operator kicks in only when you do AtmosphericData * qreal, but not when the ordering of the types is the opposite (which is what happens in the 3 * (y0 - y1) expression).

You have to write also an operator* to handle the qreal * AtmosphericData case, which must be written as a free function because the type of the left hand operand is not of the type of your class.

inline AtmosphericData operator*(const qreal& lhs, const AtmosphericData & rhs)
{
    // Just forward to the other operator (this works because I swapped the operands)
    return rhs * lhs;
}

By the way, IMHO to implement the mathematical operators you should follow the usual pattern of implementing first the assigning-versions (*=), and then call them from the "normal" (*) version; see the operator overloading FAQ for more details.

Really thanks for the link. I'll read the FAQ as soon as possible. — jepessen, Sep 02 '11 at 15:01
@jepessen: C++ is a big and complicated language, we are all noobs in some of its aspects :) By the way, if my answer solved your problem you can consider accepting if (the big tick under the votes count). — Matteo Italia, Sep 02 '11 at 15:36

Nawaz · Answer 2 · 2011-09-02T14:54:08.930

If you write :

c2 = - ((y0 - y1) * 3 + (hx * ((t1 * 2 ) + t2))) / (hx * hx);

instead of

c2 = - (3 * (y0 - y1) + (hx * ((2 * t1) + t2))) / (hx * hx);

then it should work. Because the definition of operator* in your code requires that the object of type AtmosphericData should be on the left side of *. That is, 3 * y wouldn't work, but y*3 would work where y is an object of type AtmosphericData.

If you want 3*y to work as well, then define a non-member function as:

AtmosphericData operator*(const qreal &r, const AtmosphericData& a)
{
   return d*r;//call the other overloaded, or calculate the value here if you wish!
}

I would suggest you to define other function as non-member function as well. And if needs to access private or protected members, then make it friend. Otherwise, non-member non-friend should your first choice.

score 0 · Answer 3 · answered Sep 02 '11 at 14:47

0

You are trying to multiply a AtmostphereicData by an int (3*blah and 2*blah), an operation which you don't appear to have defined.

Ddefine an operator which takes a left hand side of int and right-hand side of AtmosphereicData.

answered Sep 02 '11 at 14:47

Dan

12,857
7
40
57

score 0 · Answer 4 · answered Sep 02 '11 at 14:47

You have defined an operator * whose first argument is AtmosphericData and the second is a number. But NOT vice versa.

You should define the other operator as well (as a nonmember)

AtmosphericData operator * (qreal num, const AtmosphericData& ad )
{
    return ad*num;
}

R. Martinho Fernandes · Answer 5 · 2011-09-02T14:56:38.187

If you declare the operator inside the class, it will only work if you use your class on the left. To use your class on the right you need to also overload the operator as a free function:

AtmosphericData operator*(const qreal& qrMult, const AtmosphericData& data);

You could also use Boost.Operators and get all this for free with operator*=.

class AtmosphericData : boost::multipliable<AtmosphericData, qreal> 
{

   // blah

public:
    AtmosphericData& operator*=(const qreal& qrMult) {
        // blah blah
        return *this;
    }
    // by inheriting from boost::multipliable, this gives you both operator* for free
}

Error in overloading operator *

5 Answers5