Why is unique_ptr operator-> not const-overloaded?

Question

std::unique_ptr::operator-> has the signature

pointer operator->() const noexcept;

So operator-> is const but returns a mutable pointer. This allows for code like:

void myConstMemberFunction() const
{
    myUniquePtrMember->nonConstFunction();
}

Why does the standard allow this, and what is the best way to prevent usage as presented above?

Answer 1

Think about it like a normal pointer:

int * const i;

is a const pointer to a non-const int. You can change the int, but not the pointer.

int const * i;

is a non-const pointer to a const int. You can change the pointer but not the int.

---

Now, for unique_ptr, it's a question of whether the const goes inside or outside the <>. So:

std::unique_ptr<int> const u;

is like the first one. You can change the int, but not the pointer.

What you want is:

std::unique_ptr<int const> u;

You can change the pointer, but not the int. Or perhaps even:

std::unique_ptr<int const> const u;

Here you can't change the pointer or the int.

---

Notice how I always place the const on the right? This is a little uncommon, but is necessary when dealing with pointers. The const always applies to the thing immediately to its left, be that the * (pointer is const), or the int. See http://kuhllib.com/2012/01/17/continental-const-placement/ .

Writing const int, might lead you to thinking int const * is a const-pointer to a non-const int, which is wrong.

Answer 2

This replicates the semantics of traditional pointers. A const pointer is a pointer that cannot be mutated. However, the object it points to can.

struct bar {
  void do_bar() {}
};

struct foo {
  void do_foo() const { b->do_bar(); } // OK
  bar* const b;
};

To avoid mutating the pointee, you need the unique_ptr equivalent of const pointer to const, or

const std::unique_ptr<const bar> b;