CODEWITHSUNDEEP
c++constants
Pella86
Pella86

Reputation: 500

Const correctness and operator *

I defined a class like this:

Quaternion& conjugate();        //negates the vector component of the quaternion
Quaternion  conjugate() const;  //same but in without modifying the class...

Quaternion& operator =  (Quaternion const& Qrhs);
Quaternion& operator *= (Quaternion const& Q);
Quaternion  operator  *  (Quaternion const& Qrhs) const;

now I use this functions like this:

PRINTVAR(*this);                //this is the first time printed (a little macro to print line and file)
Quaternion vQ(0.,vn), resQ;
resQ = vQ*(this->conjugate());  //this is the method I want to discuss...
PRINTVAR(*this);                //this is the second time
resQ = *this * resQ;

and this is the output

*this: (0:0:0:0) at line: 128 in file: Quaternions.cpp
*this: (-0:-0:-0:0) at line: 131 in file: Quaternions.cpp

I thought that by calling the operator * in the line resQ = vQ*(this should be called as const)... why if I print *this again is changed?

here is the definition of the conjugate function:

Quaternion& Quaternion::conjugate(){
/* Given:  Nothing
 * Task:   Invert sign of the vector
 * Return: the class which will be modified
*/
    V3 vec;
    vec = -(this->getVector());
    x() = vec[0];
    y() = vec[1];
    z() = vec[2];
    return *this;
}

Quaternion Quaternion::conjugate() const{
    Quaternion result(*this);
    result.conjugate();
    return result;
}

Upvotes: 0

Views: 185

Answers (3)

Joachim Isaksson
Joachim Isaksson

Reputation: 181097

*this is not const (although it is used in a const method), and the c++ FAQ Lite states regarding const overloading (in the FAQ's case on a subscript operator);

When you apply the subscript operator to a MyFredList object that is non-const, the compiler will call the non-const subscript operator.

Translated, since *this is non-const, the non-const method will be called.

Upvotes: 0

Krizz
Krizz

Reputation: 11552

Probably the method in which you are using this is non-const.

The type of this a member function of a type A, is A * const. For const member function it is const A * const.

Therefore, your code will work as you expect it to do if you enter your code into const method.

If you want to force calling const overload of function you will need to do a const-cast:

  const_cast<const Quaternion * const>(this)->conjugate();

Upvotes: 0

Mark B
Mark B

Reputation: 96311

If the code you showed is in a non-const method, than the this pointer is non-const, and the non-const conjugate method is of course a better match than the const one. Return types aren't considered in overload decisions. If you want to insist that the const version is used, you can add constness: resQ = vQ*(static_cast<const Quaternion*>(this)->conjugate());

Upvotes: 3

Related Questions