一、shared_ptr
shared_ptr,使用引用计数实现对同一块内存可以有多个引用,在最后一个引用被释放时,指向的内存才释放,这也是和unique_ptr最大的区别。基本用法:
shared_ptr<int>sp1(new int(10));
cout << "sp1: " << sp1.use_count() << '\n';
cout << "sp1 = " << sp1 << " *sp1 = " << *sp1 << endl;
shared_ptr<int>sp2 = make_shared<int>(10);
cout << "sp2: " << sp2.use_count() << '\n';
cout << "sp2 = " << sp2 << " *sp2 = " << *sp2 << endl;
输出:
这个智能指针的特性“在最后一个引用被释放时,指向的内存才释放”。怎么理解这一点呢?使用自定义数据类型来看看:
class A {
public:
~A() {
cout << "dealloc A" << endl;
}
};
A* a = new A();
delete a; //调用~A
shared_ptr<A>spa = make_shared<A>(); //使用shared_ptr
cout << "spa: " << spa.use_count() << '\n';//可以看到引用计数为1
spa = nullptr;//将智能指针赋值为空指针后,先前指向内存的引用计数为0,内存被析构,调用~A
cout << "spa: " << spa.use_count() << '\n';//引用计数为0
输出:
最后看看不同方法使用智能指针的引用计数:
shared_ptr<int> p1;//默认构造,没有获取任何指针的所有权
shared_ptr<int> p2(nullptr);//同p1
shared_ptr<int> p3(new int);//拥有指向int的指针所有权
cout << "p1: " << p1.use_count() << '\n';
cout << "p2: " << p2.use_count() << '\n';
cout << "p3: " << p3.use_count() << '\n';
shared_ptr<int> p4(p3);//如果p3引用计数为0,则引用计数加1,否则同样为0
cout << "p4: " << p4.use_count() << '\n';
shared_ptr<int> p5(std::move(p4));//获取p4的引用计数
cout << "p5: " << p5.use_count() << '\n';
return 0;
输出:
二、enable_shared_from_this
std::enable_shared_from_this 是一个模板类,能让一个对象t(被 std::shared_ptr 对象 pt1 管理)生成另一个 std::shared_ptr 实例pt2 ,与 pt1 共享对象 t 的所有权。
一个类 T 继承 std::enable_shared_from_this<T> ,则会为该类 T 提供成员函数:shared_from_this 。 当 T 类型对象 t 被一个为名为 pt 的 std::shared_ptr<T> 类对象管理时,调用 T::shared_from_this 成员函数,将会返回一个新的 std::shared_ptr<T> 对象,它与 pt 共享 t 的所有权。
当类A被share_ptr管理,且在类A的成员函数里需要把当前类对象作为参数传给其他函数时,就需要传递一个指向自身的share_ptr。
struct A : std::enable_shared_from_this<A>
{
public:
std::shared_ptr<A> getptr() {
return shared_from_this();//调用shared_from_this(),返回一个新的shared_ptr<T>对象
}
~A() { std::cout << "A destroy" << std::endl; }
};
std::shared_ptr<A> gp1(new A());
std::shared_ptr<A> gp2 = gp1->getptr();
// 打印gp1和gp2的引用计数
std::cout << "gp1.use_count() = " << gp1.use_count() << std::endl;
std::cout << "gp2.use_count() = " << gp2.use_count() << std::endl;
return 0;
输出:
三、weak_ptr
该类型指针通常不单独使用(没有实际用处),只能和 shared_ptr 类型指针搭配使用。可以视为 shared_ptr 指针的一种辅助工具。借助 weak_ptr 类型指针可以获取 shared_ptr 指针的一些状态信息,比如有多少指向相同的 shared_ptr 指针、通过expired()判断shared_ptr 指针指向的堆内存是否已经被释放等等。
weak_ptr 类型指针并不会影响所指堆内存空间的引用计数。当 weak_ptr 指针的指向和某一 shared_ptr 指针相同时,weak_ptr 指针并不会使所指堆内存的引用计数加 1;同样,当 weak_ptr 指针被释放时,之前所指堆内存的引用计数也不会因此而减 1。weak_ptr<T> 模板类中没有重载 * 和 -> 运算符,这也就意味着,weak_ptr 类型指针只能访问所指的堆内存,而无法修改它。
std::shared_ptr<int> sp1(new int(10));
std::shared_ptr<int> sp2(sp1);
cout << "sp1 : "<<sp1.use_count() << endl;
cout << "sp2 : "<<sp2.use_count() << endl;
std::weak_ptr<int> wp(sp2);
cout << "wp : "<<wp.use_count() << endl;
sp2 = nullptr;
cout << "wp : " << wp.use_count() << endl;
return 0;
输出:
weak_ptr的一个作用是解决share_ptr的循环引用问题。如下面代码所示,A中引用B,B中引用A,spa和spb的强引用计数永远大于等于1,所以直到程序退出前都不会被退出,这种情况有时候在正常的业务逻辑中是不可避免的,而解决循环引用的方法是改用weak_ptr
class A {
public:
shared_ptr<B> b;
};
class B {
public:
shared_ptr<A> a;
};
int main(int argc, const char * argv[]) {
shared_ptr<A> spa = make_shared<A>();
shared_ptr<B> spb = make_shared<B>();
spa->b = spb;
spb->a = spa;
return 0;
}
使用weak_ptr
class A {
public:
shared_ptr<B> b;
~A()
{
cout << "A destroy" << endl;
}
};
class B {
public:
weak_ptr<A> a;
~B()
{
cout << "B destroy" << endl;
}
};
int main(int argc, const char* argv[]) {
shared_ptr<A> spa = make_shared<A>();
shared_ptr<B> spb = make_shared<B>();
cout << "spa = " << spa.use_count() << endl;
cout << "spb = " << spb.use_count() << endl;
spa->b = spb; //spb强引用计数为2,弱引用计数为1
spb->a = spa;
//spb->a为weak_ptr类型,不会增加强引用计数,所以spa强引用计数为1,弱引用计数为2
cout << "spa = " << spa.use_count() << endl;
cout << "spb = " << spb.use_count() << endl;
return 0;
} //main函数退出后,spa先释放,spb再释放,循环解开了
输出:
更详细内容参考:智能指针(三):weak_ptr浅析_AlbertS Home of Technology-CSDN博客_weakptr
四、unique_ptr
unique_ptr也是一种智能指针,不过它独占被管理的内存地址,如果有其它指针指向它管理的内存地址,则会引发错误。可以用move函数给其他unique_ptr赋值,调用move后,原unique_ptr就会失效,再用其访问裸指针也会发生错误。
unique_ptr<int> up(new int(5));
auto up2 = up; // 编译错误
auto up2 = move(up);
cout << *up << endl; //错误,up已经失效,无法访问其裸指针