C++ const correctness vulerability or unintended usage?

Question

I am missing something or const-correctness doesn't work quite as intended with pointers (or perhaps smart pointers since that is what I've tested?). Anyway, here is what I observed with trying out a variant of the PIMPL idiom.

I have the following declared:

class A {
public:
  A(...);
  ...
  bool update_stuff(...) const;
  ...
protected:
  bool update_stuff_impl(...) const;
  ...
private:
  struct pimpl;
  pimpl* m_pimpl;
};

And for the implementation, I have something like:

struct A::pimpl {
  pimpl(...): some_data(new some_type());
  ...
  some_method1(...); // Modifies content of some_data
  some_method2(...); // Modifies content of some_data 
  ...

  boost::shared_ptr<some_type> some_data;
};

A::A(...): m_pimpl(new pimpl(...)) {
  ...
}

bool A::update_stuff(...) const {
   if( !update_stuff_impl(...) ) {
      return false;
   }
   return true;
}

bool A::update_stuff_impl(...) const {
   //-Change content of pimpl::some_data here
   m_pimpl->some_method1(...);
   m_pimpl->some_method2(...);
   return true;
}

What I'm having trouble understanding is how I could get away with using const qualifier for the functions A::update_stuff(...) and A::update_stuff_impl(...) when I am actually modifying A::pimpl::some_data??! Or is this expected behavior or just plain bad usage? If it is one of the latter, appreciate if you can identify how it can be corrected?

Thanks for your time and interest.

Since you are not changing any class member, const correctness still holds e.g. in update_stuff_impl, you are not changing pointer m_pimpl to point to something else ! — Amit, Jun 09 '13 at 06:14
OK..that's it? That's what I thought too, but for some reason I thought const-correctness checked for more than that. I guess it makes sense that it only checks for the pointer and not its content since that could be another pointer which could be point to another pointer...and so on, which would be too much to enforce. Well, that clears it up. If you like, you can write it up as an answer and I'll select it. Thanks. — squashed.bugaboo, Jun 09 '13 at 06:25
[You underestimate compilers](http://coliru.stacked-crooked.com/view?id=8dac349ae932247e00d4f78f69a84582-5810134890c91c9c44460bfeba093fcf). — Luc Danton, Jun 09 '13 at 08:02

score 2 · Accepted Answer · answered Jun 09 '13 at 10:29

It's not a new discovery, you can read up on something like 'const is shallow' in C++. What leads to natural distinction between physical and logical const (read after the second too).

If you have pointer in class, be it smart or dumb, you're likely involved in this problem and must carefully design. Taking into account that modifying the attached data on the other end of pointer is not discovered.

Possible workararounds are to make the pointer const T* and add private member function that returns T*. Another is to restrict direct access to the pointer in general, and require a pair of functions one const and other nonconst.

score 1 · Answer 2 · answered Jun 09 '13 at 07:30

C++ protects constness of pimpl* m_pimpl variable. It doesn't allow to change the value of the pointer. But it allows to do anything with the object this pointer is pointing. Generally there is no way to protect it.

For example, consider a class member variables int a; int* b;. In a class member function we can do the following:

int a_copy = a;
a_copy = 42;
int* b_copy = b;
*b_copy = 42;

Here a_copy and b_copy are local variables. They are not protected with constness of the object you're in. So this code can be executed using const method. The difference is that a variable value has not been changed here, and *b value has been changed. Since a pointer can be easily copied, there is no way for a compiler to know if some pointer is equal to any pointer lying in a member value of const object.

C++ const correctness vulerability or unintended usage?

2 Answers2