Smart pointer Basic knowledge

A simple auto_ptr source code: You can learn how to overload operator*() and operator->().

template <class T> class auto_ptr{
    T* ptr;
public:
    explicit auto_ptr(T* p = 0) : ptr(p) {}
    ~auto_ptr()                 {delete ptr;}
    T& operator*()              {return *ptr;}
    T* operator->()             {return ptr;}
    // ...
};

auto_ptr<int> aupr;
//aupr is nullptr even you don’t initialize it.

Why smart pointer?

"Just remember to" is seldom the best solution! So we need smart pointer to perform delete operator automatically.
When throw an exception, delete will not be invoked at all, It will cause memory leaking.
In previous example codes, aupr is nullptr default. You avoid wild pointer problem.

The idea of smart pointer is putting *p into a local pointer-like object, then when it go out scope or unwind-stack when exception is thrown, It will call destructor, then delete p.

There are three kinds of smart pointer: auto_ptr, unique_ptr, and shared_ptr. But only unique_ptr and shared_ptr are recommended to use. auto_ptr is now deprecated, and should not be used in new code. When you get a chance, try doing a global search-and-replace of auto_ptr to unique_ptr in your code base.

When you construct a smart pointer, you must use 1) a pointer and 2) this pointer must be produced by new. You can’t build in this way unique_ptr<double> ptr(&df);

Why auto_ptr not recommended? 1) When you assign targetP = sourceP, it will cause sourceP set to be NULL, It will cause trouble when you use sourceP in the future. 2)You can’t create container includes auto_ptr, compiler prohibit you doing so!

auto_ptr<string> ps (new string("hello␣world") );
auto_ptr<string> ps1;
ps1 = ps; // ps will be set null.
ps->size() // it will crash the application.

auto_ptr<string> parray[5]; //compiling error.
auto_ptr<string> ps = parray[2];
//parray[2] will be set null;

Obtain the raw pointer (get), to relinquish control of the pointed object (release), and to replace the object it manages (reset).

You can get a normal pointer from smart pointer by get(). You can use three methods to create smart pointer from raw pointer.

string * cp = new string("hello␣world");
shared_ptr<string> ps;
string * cp1 = ps.get(); //use get() get normal pointer.

shared_ptr<string> ps = cp; // not allow

//method1: use constructor
shared_ptr<string> ps (cp); //ok
//method2: use temporary obj
ps = shared_ptr<string>(cp); //ok
//method3: reset
ps.reset(cp);

smart pointer has bool operator, you can use if to test it directly.

std::unique_ptr<int> ptr(new int(42));
if (ptr) std::cout << *ptr << ’\n’;
ptr.reset();
if (ptr) std::cout << *ptr << ’\n’;

smart pointer and const

shared_ptr<T> p;        ---> T * p;
const shared_ptr<T> p;   ---> T * const p;
shared_ptr<const T> p;   ---> const T * p;
const shared_ptr<const T> p; ---> const T * const p;

smart pointer is used mainly for ownership, It doesn’t support Inheritance well. Don’t use smart pointer when you want to use in polymorphous

When in doubt, prefer unique_ptr by default, and you can always later move-convert to shared_ptr if you need it. If you do know from the start you need shared ownership, however, go directly to shared_ptr via make_shared. If you compiler report error about unique_ptr, then you should consider to use shared_ptr

1.1.9.2 Smart pointer Basic knowledge