Thread: Inheritance with mutable

If I'm not mistaken, it's always members that are mutable, not *this itself.

As to a solution, the classes are not const-correct, so there's no point in trying to declare the pointer const - it gives no guarantees if you are looking for ways to get round const-correctness at the same time. (As they say, const is a "virus", it needs to propagate to all parts of the code if you want to use it properly. You can't make some parts of the code const-correct and other parts not.)

Or, instead of inheriting, make A a mutable member of B (but again, there should be some justification for that).

Originally Posted by major_tom3

Why can't I inherit a class as mutable? In other words, I'd like all methods of a base-class to be implicitly mutable:

From what I see, when you say "inherit a class as mutable", you mean to inherit a class such that all the member functions of the base class are somehow declared const, and all the member variables of the base class are somehow declared mutable.

Originally Posted by major_tom3

Why isn't it a standard feature?

Why should it be a standard feature? Consider a variant of your example:

Code:

int main()
{
    const A* p = new B;
    p->foo(); // Allowed or not allowed?
    delete p;
}

If it is allowed, it becomes a case where just looking at p->foo(), and knowing that p is a pointer to A, we cannot determine if the call is allowed or not allowed without knowing the actual type of the object that p points to at run time. If it is not allowed, then this feature breaks Liskov substitution, since replacing the const pointer to the base class with a const pointer to the derived class causes the code to behave differently.

Sometimes the alternative is that you have to declare methods as not const which conceptually are. Then you have to pass around non-const pointers where you'd prefer to pass const. Then the system really does break down. A little defined, thought-out mutability is far preferable.

Or you can use const_cast<>. *evil grin*

To the OP: maybe you can explain what you're trying to do, exactly what the base and derived classes are, etc. That's probably the only way you'll get a viable solution suggested . . . .

On a conceptual level, const member functions say, "I'm not going to modify the logical state of this object." The key word here is "logical" - if a class has a function getInformation() and this information is retrieved via, say, a database query, that class might want to cache this information locally so that it doesn't have to repeat the query all the time. But this cache is not part of the logical state. The logical state is observed through the return value of getInformation(), and assuming a proper cache invalidation mechanism, that return value is the same whether the query is executed or the cached value is returned.
So that's why we have mutable: to allow modification of members that are not part of the logical state in const member functions.

That's fine for members. But public base classes are more than that. It makes sense to have a member and say, "But this member isn't part of the logical state." The same thing doesn't make sense for a base class. That base class better be part of the logical state, or it has no business being a base class. At least, I can't think of any conceptual view of inheritance where it would make sense.