c++智能指针 unique_ptr,shared_ptr,weak_ptr

c++中使用new在堆上创建的对象，必须使用delete进行销毁，否则就会内存泄漏。有时候你会不经意间忘记了delete。就算你没有忘记delete，而程序在delete之前出现异常，那就会造成delete语句没有执行。如下：

int* pi = new int(10);
//doSomething
delete pi;

如果doSomething出现了异常，就会造成delete pi不能执行，从而造成内存泄露。

所以只能指针应运而生，智能指针的原理就是利用栈对象封装指针，然后重载*和->符号，使得这个对象看起来像个指针，在对象离开作用域调用析构函数的时候自动delete指针。c++11有3种只能指针，如下：

智能指针	说明
unique_ptr	独占指针，离开作用域后释放指针
shared_ptr	共享指针，增加计数器，计数器为0时释放指针
weak_ptr	弱指针，需要调用lock获得shared_ptr来使用

unique_ptr独占指针

unique_ptr 替代了原来的auto_ptr，指向对象具有唯一性，即同一时间只能有一个unique_ptr指向给定对象。unique_ptr创建是必须指定一个引用的指针。离开作用域后自动delete指针。

int* pi = new int(10);
cout << *pi << endl;//10
{
    unique_ptr<int> upi(pi);//创建只能指针upi指向pi。
    cout << *upi << endl;//10
}//upi离开作用域，将自动调用 delete pi。
cout << *pi << endl;//因为指针pi已经释放，所以打印不可预期的值

10
10
-572662307

因为unique_ptr具有唯一性，下面的写法都是错误的，会使得程序崩溃：

int* pi = new int(10);
unique_ptr<int> upi(pi);//正确
unique_ptr<int> upi0();//错误，创建时必须指定引用的指针。
unique_ptr<int> upi1(pi);//错误，违反唯一性，因为已经有upi指向pi
unique_ptr<int> upi2 = upi;//错误

但是有时候，我们确实需要把一个独占指针赋值给另一个独占指针，那怎么办呢？c++为我们提供了一个move函数，如下：

int* pi = new int(10);
unique_ptr<int> upi(pi);
cout << &upi <<"  " << *upi<< endl;
unique_ptr<int>upi1 = move(upi);
cout << &upi1 << "  " << *upi1 << endl;
//cout << *upi << endl;错误，move函数会移除upi对pi的引用。

000000E980DEFBE8  10
000000E980DEFC08  10

move函数还让我们可以把unique_ptr作为参数传递，如下：

void test(unique_ptr<int> upi) {
    cout <<&upi << "  "<< *upi << endl;
}

int main() {
    int* pi = new int(10);
    unique_ptr<int> upi(pi);
    cout << &upi <<"  " << *upi<< endl;
    test(move(upi));

    cout << *pi << endl;//打印不可预期值，因为在test函数结束时已经调用了delete
    return 0;
}

000000472B8FFB38  10
000000472B8FFC38  10
-572662307

还可以使用reset方法手动delete原对象，reset有双重含义：

• delete原对象
• 重新引用新对象

用法如下：

int* pi = new int(10);
unique_ptr<int> upi(pi);

upi.reset(new int(100));//如果不带参数，则不绑定新对象

cout << *pi << endl;//打印不可预期值
cout << *upi << endl; //如果reset不带参数，则此处错误

-572662307
100

release方法可以释放对原对象的控制权。

int* pi = new int(10);
unique_ptr<int> upi(pi);
upi.release();//释放对pi的绑定
cout << *pi << endl;//正确
//cout << *upi << endl; 错误

10

shared_ptr共享指针

共享指针内包含指向原对象的计数器，计数器共享，离开作用域时如果计数器为减为0时，调用delete。理解了unique_ptr后shared_ptr就比较好理解了。reset函数释放对原对象的引用，使得计数器减一。

void test(shared_ptr<int> spi) {
    cout <<spi.use_count()<< endl;//3
}

int main() {
    int* pi = new int(10);
    shared_ptr<int> spi(pi);
    cout << spi.use_count() << endl;//1
    shared_ptr<int> spi1 = spi;
    cout << spi1.use_count() << " " << spi1.use_count() <<  endl;//2,计数器共享
    test(spi);//计数器+1
    cout << spi.use_count() << endl;//2
    spi1.reset();//spi1释放引用，计数器-1
    cout << spi.use_count() << endl;//1

    return 0;
}

1
2 2
3
2
1

共享指针很强大，可以联合标准容器一起使用。而独占指针却不行。

weak_ptr弱指针

weak_ptr是为配合shared_ptr而引入的一种智能指针来协助shared_ptr工作，它可以从一个shared_ptr或另一个weak_ptr对象构造，它的构造和析构不会引起引用计数的增加或减少。没有重载 * 和 -> 但可以使用lock获得一个可用的shared_ptr对象。

int* pi = new int(10);
shared_ptr<int> spi(pi);
cout << spi.use_count() << endl;
weak_ptr<int> wpi(spi);//不改变计数器
cout << spi.use_count() << endl;
shared_ptr<int> spi1 = wpi.lock();//计数器+1
cout << spi.use_count() << endl;
spi1.reset();
spi.reset();
cout << spi.use_count() << endl;

shared_ptr<int> spi2 = wpi.lock();
cout << (spi2 == nullptr) << endl;

1
1
2
0
1

工厂方法

通过以上三种智能指针的使用，我们完全可以去掉delete的使用，但是还必须使用new，这样会让人感觉有种不对称性，不美。所以提供了创建智能指针的工厂方法，如下：

int main() {
    unique_ptr<int> upi = make_unique<int>(10);
    cout << *upi << endl;
    shared_ptr<int> spi = make_shared<int>(100);
    cout << *spi << endl;

    return 0;
}

10
100