Question

I have a member function which is declared const and modifies data via a pointer. This seems misleading. Should I remove the const keyword?

I would like to know how others handle this situation in their code. Do people just add a comment to clarify what is going on? Do they not add the const keyword to the member function? Maybe something else completely?

Any advice is appreciated.

Answer 1

You have essentially two choices:

Deep constness:

class Foo
{
    T * ptr;
public:
    T       & operator*()       { return *ptr; }
    T const & operator*() const { return *ptr; }
    T       * operator->()       { return ptr; }
    T const * operator->() const { return ptr; }
};

Shallow constness:

class Foo
{
    T * ptr;
public:
    T & operator*() const { return *ptr; }
    T * operator->() const { return ptr; }
};

It’s really up to you, and to the purpose of your class. If the class is a smart pointer, it would seem reasonable to have shallow constness semantics, since the class is supposed to be as similar to a raw pointer as possible (and you can of course have a constant raw pointer to a non-constant pointee).

Otherwise, you should ask yourself why you would be exposing access to a member pointer object at all. It’s certainly possible that you want to give mutable access via constant references to your class, but I imagine those are special and rare circumstances. There shouldn’t really be that many raw pointers in your code in the first place. Returning a deeply-const reference by dereferencing a pointer should be fine, but usually in better encapsulated “getter” functions which hide the fact that there is a pointer inside your class, like T const & get() const { return *ptr; }.