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?
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.
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;
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.