[c++] 智能指针(shared_ptr, weak_ptr, unique_ptr)

已于 2024-03-26 10:51:45 修改
阅读量800 收藏 25
点赞数 13
分类专栏： c/c++ 文章标签： c++ 开发语言
于 2024-02-26 09:55:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38184628/article/details/136287276
版权
本文介绍了C++中的智能指针机制，包括shared_ptr（共享指针）的引用计数原理，以及如何避免循环引用问题的weak_ptr。同时讨论了unique_ptr（独占智能指针）的特点和自动析构的特性。
摘要由CSDN通过智能技术生成

c++ 中的智能指针让 c++ 看起来像 java，go 这种带 GC 的语言，但和 GC 又不完全相同。c++ 中的智能指针使用引用计数，当引用计数减为 0 的时候就会立即释放资源，释放资源具有实时性；而像 java，go 这样的 GC 语言，当对象不被引用时，可能不会立即释放资源，资源的释放有滞后性。 

如果不使用智能指针，需要开发者使用 new 和 delete 创建和销毁对象。

使用智能指针，开发者不需要手动来释放资源，当引用计数变为 0 时自动释放。

就这一个好处。

使用智能指针需要包含头文件 memory。

1 shared_ptr 和 weak_ptr

1.1 shared_ptr

shared_ptr 是共享指针，对于一个对象来说，可以有多个 shared_ptr 指针指向它，每多一个指针指向它，这个对象的引用计数就会增加 1。shared_ptr 有一个函数是 reset()，每 reset() 一次，对象的引用计数就会减去 1，当引用计数变为 0 的时候，就会释放对象。

shared_ptr 的常用方法：

use_count()获取对象的引用计数
get()获取对象的原始指针
reset()引用计数减 1，或者使用一个新的对象重置这个智能指针

shared_ptr 示例代码如下：

#include <iostream>
#include <string>
#include <memory>

class Test {
public:
  Test() {
    std::cout << "Test()" << std::endl;
  }

  ~Test() {
    std::cout << "~Test()" << std::endl;
  }

  void Do() {
    std::cout << "Test() Do()" << std::endl;
  }
};

void SharedParam(std::shared_ptr<Test> t) {
  std::cout << "SharedParam, t.use_count() = " << t.use_count() << std::endl;
}

void SharedRefParam(std::shared_ptr<Test> &t) {
  std::cout << "SharedRefParam, t.use_count() = " << t.use_count() << std::endl;
}

int main() {
  std::shared_ptr<Test> t1 = std::make_shared<Test>();
  std::shared_ptr<Test> t2 = t1;
  std::shared_ptr<Test> t3 = t1;

  std::cout << "t1.use_count() = " << t1.use_count() << std::endl;
  std::cout << "t2.use_count() = " << t2.use_count() << std::endl;
  std::cout << "t3.use_count() = " << t3.use_count() << std::endl;
  std::cout << std::endl;

  SharedParam(t1);
  SharedRefParam(t1);

  t3.reset();
  std::cout << "after t3 reset" << std::endl;
  std::cout << "t1.use_count() = " << t1.use_count() << std::endl;
  std::cout << "t2.use_count() = " << t2.use_count() << std::endl;
  std::cout << "t3.use_count() = " << t3.use_count() << std::endl;
  std::cout << std::endl;

  t2.reset();
  t1.reset();
  std::cout << "after t2, t1 reset" << std::endl;
  std::cout << "t1.use_count() = " << t1.use_count() << std::endl;
  std::cout << "t2.use_count() = " << t2.use_count() << std::endl;
  std::cout << "t3.use_count() = " << t3.use_count() << std::endl;
  std::cout << std::endl;

  std::shared_ptr<Test> t4;
  t4.reset(new Test);
  std::cout << "t2.use_count() = " << t2.use_count() << std::endl;
  std::cout << "t4.use_count() = " << t4.use_count() << std::endl;
  std::cout << std::endl;

  Test *t5 = t4.get();
  t5->Do();
  return 0;
}

 代码编译之后，运行结果如下：

1.2 weak_ptr

1.2.1 shared_ptr 存在的问题：循环引用，无法自动释放资源

要了解为什么需要 weak_ptr 就需要了解 shared_ptr 存在的问题。

shared_ptr 的问题示例代码如下，按我们的理解，main() 函数返回的时候，a，b 两个共享指针会自动释放。代码中即使分别对 a 和 b 进行了 reset，也不能自动释放。

#include <iostream>
#include <string>
#include <memory>

class B;

class A {
public:
  A() {
    std::cout << "A()" << std::endl;
  }

  ~A() {
    std::cout << "~A()" << std::endl;
  }

  std::shared_ptr<B> b_;
};

class B {
public:
  B() {
    std::cout << "B()" << std::endl;
  }

  ~B() {
    std::cout << "~B()" << std::endl;
  }

  std::shared_ptr<A> a_;
};

int main() {
  std::shared_ptr<A> a = std::make_shared<A>();
  std::shared_ptr<B> b = std::make_shared<B>();

  a->b_ = b;
  b->a_ = a;

  a.reset();
  b.reset();
  return 0;
}

运行结果如下，类 A 和类 B 的析构函数并没有被调用。

main() 函数返回时的析构过程：

（1）a 和 b 析构，a 和 b 的引用计数减 1

（2）销毁 a 中的 b，这个时候 b 的引用计数要减为 0，减为 0 的时候就要销毁 b 中的成员 a；销毁 b 中的 a，同理 b 中的 a 的引用计数要减为 0。两者死锁，最终到是 a 和 b 都无法析构。

1.2.2 weak_ptr

weak_ptr 不会增加对象的引用计数，当有循环引用这种情况时，可以使用 weak_ptr 来代替 shared_ptr，以此来解决 shared_ptr 不能自动释放的问题。

本来 shared_ptr 是用来简化开发工作的，这里又引入了 weak_ptr，通过 weak_ptr 又不能直接访问对象，还要使用 lock 来获取对象。开发工作并没有简化多少。

本来 c++ 中的引用是为了减少指针操作的，但是 c++ 中的引用又分左值引用，右值引用，导致用起来并不比指针简单。

代码如下所示，A 中对 B 的引用由  shared_ptr 改成了 weak_ptr。

#include <iostream>
#include <string>
#include <memory>

class B;

class A {
public:
  A() {
    std::cout << "A()" << std::endl;
  }

  ~A() {
    std::cout << "~A()" << std::endl;
  }

  std::weak_ptr<B> b_;
};

class B {
public:
  B() {
    std::cout << "B()" << std::endl;
  }

  ~B() {
    std::cout << "~B()" << std::endl;
  }

  std::shared_ptr<A> a_;
};

int main() {
  std::shared_ptr<A> a = std::make_shared<A>();
  std::shared_ptr<B> b = std::make_shared<B>();

  a->b_ = b;
  b->a_ = a;

  int a_use_count = a.use_count();
  int b_use_count = b.use_count();
  std::cout << "a use count = " << a_use_count << ", b use count = " << b_use_count << std::endl;

  a.reset();
  b.reset();
  return 0;
}

代码编译之后，运行结果如下，可以看到 A 和 B 的析构函数都被调用了。

因为 A 中对 B 的引用是 weak_ptr，weak_ptr 不会增加引用计数，所以 b 的引用计数是 1。

通过 weak_ptr 不能直接访问对象，要通过 lock() 获取 shared_ptr，lock() 不为空，则可用；为空，说明对象已经释放了。通过 expired() 方法也能确定 shared_ptr 是不是已经过期了。

#include <iostream>
#include <string>
#include <memory>

class B;

class A {
public:
  A() {
    std::cout << "A()" << std::endl;
  }

  ~A() {
    std::cout << "~A()" << std::endl;
  }

  void Do() {
    std::cout << "Do()" << std::endl;
  }
};

int main() {
  std::shared_ptr<A> a = std::make_shared<A>();
  std::weak_ptr<A> b = a;

  std::cout << "1, a use count = " << a.use_count() << ", b use count = " << b.use_count() << std::endl;
  a.reset();
  std::cout << "2, a use count = " << a.use_count() << ", b use count = " << b.use_count() << std::endl;
  if (b.lock()) {
    std::cout << "shared a exists" << std::endl;
  } else {
    std::cout << "shared a not exists" << std::endl;
  }

  std::cout << "b.expired() = " << b.expired() << std::endl;

  a.reset(new A);
  b = a;
  std::cout << "3, a use count = " << a.use_count() << ", b use count = " << b.use_count() << std::endl;
  b.reset();
  std::cout << "4, a use count = " << a.use_count() << ", b use count = " << b.use_count() << std::endl;
  if (b.lock()) {
    std::cout << "shared a exists" << std::endl;
  } else {
    std::cout << "shared a not exists" << std::endl;
  }

  b = a;
  if (b.lock()) {
    auto sp = b.lock();
    sp->Do();
  }


  return 0;
}

运行结果如下：

2 unique_ptr

unique_ptr 是独占智能指针，永远只能有一个指针指向这个对象。

在不同智能指针间传递需要通过 std::move() 来进行。

示例代码如下所示：

#include <iostream>
#include <string>
#include <memory>

class A {
public:
  A() {
    std::cout << "A()" << std::endl;
  }

  ~A() {
    std::cout << "~A()" << std::endl;
  }

  void Do() {
    std::cout << "Do()" << std::endl;
  }
};

int main() {
  std::unique_ptr<A> u1 = std::make_unique<A>();
  std::unique_ptr<A> u2(new A);
  std::unique_ptr<A> u3(std::make_unique<A>());

  if (u1) {
    std::cout << "u1 Do()" << std::endl;
    u1->Do();
  }
  u1.reset();
  if (u1) {
    std::cout << "u1 Do() after u1.reset()" << std::endl;
  }

  if (u2) {
    std::cout << "u2 Do()" << std::endl;
    u2->Do();
  }
  std::unique_ptr<A> u4 = std::move(u2);
  if (u2) {
    std::cout << "u2 Do()i after u2 moved" << std::endl;
    u2->Do();
  }

  return 0;
}

unique_ptr 自己调用 reset() 或者使用 std::move() 转移之后，自己就会变为 nullptr。

3 自动析构

（1）[普通对象] 全局和局部的对象，在函数返回时析构

#include <iostream>
#include <string>
#include <memory>

class A {
public:
  A() {
    std::cout << "A()" << std::endl;
  }

  ~A() {
    std::cout << "~A()" << std::endl;
  }

  void Do() {
    std::cout << "Do()" << std::endl;
  }
};

A a1;
void Test() {
  A a2;
}

int main() {
  std::cout << "main" << std::endl;
  Test();
  A a3;
  return 0;
}

（2）[普通对象] 对象指针不会自动释放，需要调用 delete 手动释放

#include <iostream>
#include <string>
#include <memory>

class A {
public:
  A() {
    std::cout << "A()" << std::endl;
  }

  ~A() {
    std::cout << "~A()" << std::endl;
  }

  void Do() {
    std::cout << "Do()" << std::endl;
  }
};

A *a1;
void Test() {
  A *a2 = new A;
}

int main() {
  std::cout << "main" << std::endl;
  Test();
  A *a3 = new A;
  return 0;
}

（3）[普通对象] 对象释放的时候，对象中的对象成员会自动释放

#include <iostream>
#include <string>
#include <memory>

class A {
public:
  A() {
    std::cout << "A()" << std::endl;
  }

  ~A() {
    std::cout << "~A()" << std::endl;
  }

  void Do() {
    std::cout << "Do()" << std::endl;
  }
};

class B {
public:
  B() {
    std::cout << "B()" << std::endl;
  }

  ~B() {
    std::cout << "~B()" << std::endl;
  }

  A a;
};

int main() {
  std::cout << "main" << std::endl;
  A a1;
  return 0;
}

（4）[智能指针] 全局智能指针，局部智能指针，对象中的智能指针会自动释放

#include <iostream>
#include <string>
#include <memory>

class A {
public:
  A() {
    std::cout << "A()" << std::endl;
  }

  ~A() {
    std::cout << "~A()" << std::endl;
  }

  void Do() {
    std::cout << "Do()" << std::endl;
  }
};

class B {
public:
  B() {
    std::cout << "B()" << std::endl;
  }

  ~B() {
    std::cout << "~B()" << std::endl;
  }

  std::shared_ptr<A> a1;
  std::unique_ptr<A> a2;
};

std::shared_ptr<A> sa1;
std::unique_ptr<A> ua1;

int main() {
  std::cout << "main" << std::endl;
  sa1 = std::make_shared<A>();
  ua1 = std::make_unique<A>();

  std::shared_ptr<A> sa2 = std::make_shared<A>();
  std::unique_ptr<A> ua2 = std::make_unique<A>();

  B b;
  b.a1 = std::make_shared<A>();
  b.a2 = std::make_unique<A>();
  return 0;
}

（5）[智能指针] 如果智能指针所在的对象或者容器不会自动析构，那么智能指针也不能析构

#include <iostream>
#include <string>
#include <memory>
#include <vector>

class A {
public:
  A() {
    std::cout << "A()" << std::endl;
  }

  ~A() {
    std::cout << "~A()" << std::endl;
  }

  void Do() {
    std::cout << "Do()" << std::endl;
  }
};

class B {
public:
  B() {
    std::cout << "B()" << std::endl;
  }

  ~B() {
    std::cout << "~B()" << std::endl;
  }

  std::shared_ptr<A> a;
};

int main() {
  B *b = new B;
  b->a = std::make_shared<A>();
  return 0;
}
王燕龙技术笔记
关注
  • 13
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
智能指针shared_ptr
蹦跶跶
05-08 884
C++智能指针智能指针概述动态内存智能指针智能指针shared_ptr基本原理shared_ptr的一些操作构造函数和析构函数自定义运算符shared_ptr的使用注意事项 智能指针概述 动态内存 在C++中，动态内存的管理是用一对运算符完成的：new和delete， new：在动态内存中为对象分配一块空间并返回一个指向该对象的指针 delete：指向一个动态对象的指针，销毁对象，并释放与之关联的内存。 动态内存管理经常会出现两种问题： 一种是忘记释放内存，会造成内存泄漏； 一种是尚有指针引用内存的情
智能指针 shared_ptr
fuyouzhiyi的博客
11-16 685
智能指针创建 std::shared_ptr<int> p1; //不传入任何实参 std::shared_ptr<int> p2(nullptr); //传入空指针 nullptr std::shared_ptr<int> p3(new int(10));//构建一个指向一块存有 10 这个 int 类型数据的堆内存空间d的shared_ptr 智能指针。 std::shared_ptr<int> p3 = std::make_
智能指针-shared_ptr
weixin_45174023的博客
06-11 1047
手写智能指针
C++11新特性之智能指针(shared_ptr/unique_ptr/weak_ptr)
09-01
本文主要讨论了三种智能指针：`shared_ptr`、`unique_ptr`和`weak_ptr`。 首先，`shared_ptr`是引用计数型智能指针，它维护了一个内部的引用计数，用于跟踪有多少个`shared_ptr`实例指向同一对象。当创建一个新的`...
C++ unique_ptr weak_ptr shared_ptr auto_ptr智能指针.doc
07-23
在 C++ 中，有四种智能指针：auto_ptr、unique_ptr、shared_ptr 和 weak_ptr，每种智能指针都有其特点和使用场景。 一、auto_ptr auto_ptr 是 C++98 中引入的智能指针，它可以自动释放动态分配的内存。但是，auto_...
C++11 智能指针之shared_ptr代码详解
08-19
C++11智能指针之shared_ptr是一个非常重要且实用的特性，它为C++的动态内存管理提供了安全性和便利性。在C++中，动态分配的内存资源在使用完毕后必须被显式地释放，否则会造成内存泄漏。为了避免这种情况，传统的...
浅析Boost智能指针:scoped_ptr shared_ptr weak_ptr
09-05
【Boost智能指针详解：scoped_ptr、shared_ptr与weak_ptr】 智能指针是C++中用来自动管理动态分配内存的对象，它可以确保在适当的时间释放内存，以防止内存泄漏。Boost库提供了一组智能指针类型，包括scoped_ptr、...
C++(13): 智能指针shared_ptr
最新发布
tecsai的博客
04-03 1125
shared_ptr智能指针，本质是“离开作用域会自动调整(减小)引用计数，如果引用计数为0，则会调用析构函数”。这样一来，就进化成类似于int、float等的一种会被自动释放的类型。
智能指针： share_ptr(共享智能指针)
比雅尼·斯特劳斯特鲁普（Bjarne Stroustrup）曾说过：如果你没看过这些博客，那么你的编程不会拥有智慧，你的代码不可能附有灵魂。
05-26 1460
auto智能指针淘汰了 对象所有权的转移，比如在函数传参过程中，对象所有权不会返还，从而存在潜在的内存崩溃问题;不能指向数组，也不能作为STL容器的成员。
C++(标准库):04---智能指针之shared_ptr
董哥的黑板报
04-10 1347
一、shared_ptr类 头文件：#include<memory> 智能指针，是一个模板。创建智能指针时，必须提供指针所指的类型 如果当做提条件判断，则是检测其是否为空 shared_ptr<string> p1; //指向string shared_ptr<list<int>> p2;//指向int的list if(p1 &...
C++ 智能指针 shared_ptr
嵌入式与人工智能
10-07 287
shared_ptrshared_ptr创建 shared_ptr 对象检查 shared_ptr 对象的引用计数创建空的 shared_ptr 对象分离关联的原始指针instance analysisfrom shared_ptr shared_ptr 是C++11提供的一种智能指针类，它足够智能，可以在任何地方都不使用时自动删除相关指针，从而帮助彻底消除内存泄漏和悬空指针的问题。 它遵循共享所有权的概念，即不同的 shared_ptr 对象可以与相同的指针相关联，并在内部使用引用计数机制来实现这一点。
c++智能指针shared_ptr
aaaaaacc7的博客
12-25 333
1.为什么需要shared_ptr智能指针 我们在日常使用指针过程中一般标准的大致流程应该是这样的。 void funcTest(){ int *pI = new int; //doSomething delete pI; } 但如果我们由于种种原因忘记在最后delete掉在堆栈上分配的对象，就会造成内存泄露。 还有这么一个情景 void funcTest0(int *pI){ //doSomething delete pI; } void funcTest1
C++智能指针详解：unique_ptr, weak_ptr, shared_ptr, auto_ptr
"本文主要介绍了C++中的四种智能指针：auto_ptr、unique_ptr、shared_ptr和weak_ptr，包括它们的使用方式、工作机制以及可能存在的缺陷。智能指针是为了解决C++中动态内存管理和指针操作可能导致的问题，如内存泄漏...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值