smart-pointers

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 ,

I've recently come across the need to apply a pointer-to-member to the object designated by an iterator. I've tried the natural syntax : ite->*ptr = 42; To my dismay, it didn't compile. Iterators don't overload operator->* , but more surprisingly neither do smart pointers. I needed to resort to the following clunkiness : (*ite).*ptr = 42; Experimenting (see the live example below) has shown that such a syntax seems to be achievable for custom classes, for both pointers-to-members and pointers-to-member-functions, at least since C++14. Thus : Is there a reason the standard pointer-like classes

Let me pose my question through an example. #include <memory> std::unique_ptr<int> get_it() { auto p = new int; return p; } int main() { auto up ( get_it() ); return 0; } This fails to compile with the following error: a.cpp:5:9: error: could not convert ‘p’ from ‘int*’ to ‘std::unique_ptr<int>’ return p; ^ Why isn't there an automatic conversion from a raw pointer to a unique one here? And what should I be doing instead? Motivation: I understand it's supposed to be good practice to use smart pointers for ownership to be clear; I'm getting a pointer (which I own) from somewhere, as an int* in

I want to use the make_shared<T> function with a derived class, like below class Base { public: typedef std::shared_ptr<Base> Ptr; }; class Derived : public Base {}; Base::Ptr myPtr = std::make_shared(/* Derived() */ ); How can I tell make_shared to build such an object? I want to avoid the classical Base::Ptr ptr = Base::Ptr(new Derived()); To make use of the single alloc in the make_shared function. std::shared_ptr has a converting constructor that can make a shared_ptr<Base> from a shared_ptr<Derived> , so the following should work: #include <memory> class Base { public: typedef std::shared

I'd like to convert a base class pointer to a derived class pointer as a function argument without using dynamic_pointer_cast class Base { public: typedef std::shared_ptr < Base > Ptr; virtual ~Base ( ); ... }; class Derive : public Base { public: typedef std::shared_ptr < Derive > Ptr; ... }; void foo( Derive::Ptr ptr ) { ... } Base::Ptr ptr1 ( new Derive ); foo( ptr1 ); The above code will give an error while calling foo. This can be avoided by typecasting ptr1 into a Dervie pointer using std::dynamic_pointer_cast. Base::Ptr ptr1 ( new Derive ); foo ( std::dynamic_pointer_cast < Derive > (