Question

Let’s say you have a class

    class C 
    {
      int * i;

      public:

         C(int * v):i(v) {};

         void method() const;  //this method does not change i
         void method();        //this method changes i
    }

Now you may want to define const instance of this class

    const int * k = whatever;
    const C c1(k); //this will fail

but this will fail because of non-const int C’s constructor C(int * v)

so you define a const int constructor

    C(const int * v):i(v) {}; //this will fail also

But this will fail also since C’s member “int * i” is non-const.

What to do in such cases? Use mutable? Casting? Prepare const version of class?

edit: After discussion with Pavel (below) I investigated this problem a bit. To me what C++ does is not correct. Pointer target should be a strict type, that means that you could not for example do the following:

int i;
const int * ptr;
ptr = & i;

In this case language grammar treats const as a promise not to change pointer’s target. In addition int * const ptr is a promise not to change pointer value itself. Thus you have two places where const can be applied. Then you may want your class to model a pointer (why not). And here things are falling into pieces. C++ grammar provides const methods which are able to promise not to change field’s values itself but there is no grammar to point out that your method will not change targets of your in-class pointers.

A workaround is to define two classes const_C and C for example. It isn’t a royal road however. With templates, their partial specializations it’s hard not to stuck into a mess. Also all possible arguments variations like const const_C & arg, const C & arg, const_C & arg, C & arg don’t look pretty. I really don’t know what to do. Use separate classes or const_casts, each way seems to be wrong.

In both cases should I mark methods which don’t modify pointer’s target as const? Or just follow traditional path that const method doesn’t change object’s state itself (const method don’t care about pointer target). Then in my case all methods would be const, because class is modelling a pointer thus pointer itself is T * const. But clearly some of them modify pointer’s target and others do not.

Answer 1

Your example doesn’t fail, k is passed by value. The member i is ‘implicitly constant’ as direct members of C can’t be changed when the instance is constant.
Constness says that you can’t change members after initialization, but initializing them with values in the initialization list is of course allowed – how else would you give them a value?

What doesn’t work is invoking the constructor without making it public though 😉

update addressing updated question:

Yes, C++ forces you into some verboseness sometimes, but const correctness is a common standard behaviour that you can’t just redefine without breaking expectations. Pavels answer already explains one common idiom, which is used in proven libraries like the STL, for working around this situation.

Sometimes you have to just accept that languages have limitations and still deal with the expectations of the users of the interface, even if that means applying an apparently sub-optimal solution.