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 <//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

你可能感兴趣的:(boost)