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?

I expected it's because the operator . cannot be overloaded. — erip
– erip, Commented Dec 17, 2015 at 12:01
In C++ const is shallow. An int* const also allows you to modify the pointed to object. — Bo Persson
– Bo Persson, Commented Dec 17, 2015 at 12:03
The same code would be allowed if the pointer were not smart. The constness applies to the pointer, not to the pointee. — juanchopanza
– juanchopanza, Commented Dec 17, 2015 at 12:03
We have std::experimental::propagate_const if you want to propagate it. — T.C.
– T.C., Commented Dec 17, 2015 at 12:06

BoBTFish · Accepted Answer · 2015-12-17 12:16:04Z

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.

juanchopanza · Accepted Answer · 2015-12-17 12:22:14Z

7

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;

edited Dec 17, 2015 at 12:22

answered Dec 17, 2015 at 12:04

juanchopanza

228k35 gold badges421 silver badges493 bronze badges

Collectives™ on Stack Overflow

Why is unique_ptr operator-> not const-overloaded?

2 Answers 2

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related