Question

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;
}

Answer 1

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());