运算符不应该是常数，但它可以

Question

I implemented a class MyMatrix that holds a pointer to an abstract class Matrix (the pointer is _matrix). the operator += calls the method add and adds the _matrix variables. therefore, _matrix which is a class variable is changed, thus the += operator CANNOT be constant, but for some reason the compiler allows me to set it as const, and there are no exceptions. why is that?

const MyMatrix& MyMatrix::operator +=(const MyMatrix& other) const
{
    _matrix->add(*other._matrix);
    return *this;
}

this is add:

void add(Matrix &other)
{
    for (int i = 0; i < other.getSize(); i++)
    {
        Pair indexPair = other.getCurrentIndex();
        double value = other.getValue(indexPair);
        pair<Pair, double> pairToAdd(indexPair, value);
        other.next();
        if (pairToAdd.second != 0)
        {
            setValue(pairToAdd.first, getValue(pairToAdd.first) + pairToAdd.second);
        }
    }
    initializeIterator();
}  

Answer 1

operator+= is allowed to be const because most probably you have declared the _matrix member as a simple pointer. Therefore, operator+= does not change the state of MyMatrix because you are not changing the pointer, but the object pointed to.

It is up to you to decide whether it is a good idea to declare operator+= as const. Most probably it is not even if the compiler allows it. It will only confuse the users of your class.

Answer 2

The const method makes the:

Matrix* _matrix;

pointer constant in the following manner:

Matrix* const _matrix;

not in that way:

const Matrix* _matrix;

That is, the pointer is const, not the pointee . Hence, you can call non-const methods on _matrix .

If you want to force constness of a pointee in a const method, use the trick from this SO answer.