std::unique_ptr+C++智能指针shared_ptr

• 记得包含头文件memory

#include
#include
using namespace std;
class my_class {
public:int variable1;int variable2;char variable3;double variable4;char variable5;char variable6;};
class my_class1: public my_class {
public:int add&＃61;123;};
int main() {my_class1 parent;shared_ptr<my_class1> ref &＃61; shared_ptr<my_class1>(&parent);shared_ptr<my_class> pointer &＃61; dynamic_pointer_cast<my_class>(ref);printf("%d\n", sizeof(my_class));return 1;
}


• 其实这算啥
• dynamic_pointer_cast这个函数把一个父类的共享指针
  • 转化成
  • 一个子类的共享指针
• 上面的东西应该是我在腾讯时候记下的&＃xff0c;但是我2021年6月16日觉得我说反了
  • 应该是把子类的共享指针
  • 转化成
  • 一个父类的共享指针吧&＃xff01;

#include
int main()
{// 创建一个unique_ptr实例std::unique_ptr<int> pInt(new int(5));std::cout << *pInt;
}


std::make_unique玩玩

#include
int main()
{// 创建一个unique_ptr实例std::unique_ptr<int> pInt&＃61; std::make_unique<int>(45);std::cout << *pInt;
}


7. unique_ptr使用场景

1 为动态申请的资源提供异常安全保证

void Func()
{int *p &＃61; new int(5);// ...&＃xff08;可能会抛出异常&＃xff09;delete p;
}


• 当我们动态申请内存后&＃xff0c;有可能我们接下来的代码由于抛出异常或者提前退出&＃xff08;if语句&＃xff09;而没有执行delete。

• 解决方法是用unique_ptr管理动态内存&＃xff0c;
  • 只要 unique_ptr 指针创建成功&＃xff0c;
  • 其析构函数都会被调用&＃xff0c;
  • 确保动态资源被释放

void Func()
{unique_ptr<int> p(new int(5));
}


canci

• 添加链接描述

• 标准的共享所有权的智能指针
• 允许多个指针指向同一个对象
• memory文件中(非memory.h),
• 命名空间 std

• 为解决 auto_ptr 在对象所有权上的局限性(auto_ptr 是独占的), 在使用引用计数的机制上提供可共享所有权的智能指针, 需额外开销:
• (1) shared_ptr 对象除
  • 包括一个所拥有对象的指针外,
  • 还包括一个引用计数代理对象的指针
• (2) 时间开销主要在初始化和拷贝上,
  • *和->操作符重载的开销跟auto_ptr一样
• (3) 开销并不是我们不使用shared_ptr的理由,
  • 永远不要进行不成熟的优化, 直到性能分析器告诉你这一点

使用方法:

• 模板函数 make_shared 创,
• 类型(’<>‘中)及参数(’()&＃39;内),
• 参数与类型匹配

std::shared_ptr<int> sp1 &＃61; std::make_shared<int>(10);
std::shared_ptr<std::string> sp2 &＃61; std::make_shared<std::string>("Hello c&＃43;&＃43;");


• 也auto保make_shared

auto sp3 &＃61; std::make_shared<int>(11);
printf("sp3&＃61;%d\n", *sp3);
auto sp4 &＃61; std::make_shared<std::string>("C&＃43;&＃43;11");
printf("sp4&＃61;%s\n", (*sp4).c_str());


成员函数

• use_count &＃xff1a;引用计数个数
• unique &＃xff1a;独占所有权( use_count 为 1)&＃xff1f;
• swap 交换 shared_ptr(即交换所拥有的对象)
• reset 放弃内部对象的所有权或变更拥有对象, 引起原有对象引用计数减
• get 返回内部对象(指针), 由于已经重载了()方法, 因此和直接使用对象是一样的.如 shared_ptr sp(new int(1)); sp 与 sp.get()是等价的

std::shared_ptr<int> sp0(new int(2));std::shared_ptr<int> sp1(new int(11));std::shared_ptr<int> sp2 &＃61; sp1;printf("%d\n", *sp0); // 2printf("%d\n", *sp1); // 11printf("%d\n", *sp2); // 11sp1.swap(sp0);printf("%d\n", *sp0); // 11printf("%d\n", *sp1); // 2printf("%d\n", *sp2); // 11std::shared_ptr<int> sp3(new int(22));std::shared_ptr<int> sp4 &＃61; sp3;printf("%d\n", *sp3); // 22printf("%d\n", *sp4); // 22sp3.reset(); printf("%d\n", sp3.use_count()); // 0printf("%d\n", sp4.use_count()); // 1printf("%d\n", sp3); // 0printf("%d\n", sp4); // 指向所拥有对象的地址std::shared_ptr<int> sp5(new int(22));std::shared_ptr<int> sp6 &＃61; sp5;std::shared_ptr<int> sp7 &＃61; sp5;printf("%d\n", *sp5); // 22printf("%d\n", *sp6); // 22printf("%d\n", *sp7); // 22printf("%d\n", sp5.use_count()); // 3printf("%d\n", sp6.use_count()); // 3printf("%d\n", sp7.use_count()); // 3sp5.reset(new int(33)); printf("%d\n", sp5.use_count()); // 1printf("%d\n", sp6.use_count()); // 2printf("%d\n", sp7.use_count()); // 2printf("%d\n", *sp5); // 33printf("%d\n", *sp6); // 22printf("%d\n", *sp7); // 22


shared_ptr赋值构造和拷贝构造:

auto r&＃61;std::make_shared<int>();
r指向的对象只有一引用, 其use_count &＃61;&＃61; 1
auto q&＃61;r; (或auto q(r);)
//给q赋, 令指另一个地址, q原来指向的对象的引用计数减1(如果为0, 释放内存),
//r指向的对象的引用计数加1, 此时 q 与 r 指向同一个对象,
//并且其引用计数相同, 都为原来的值加1.


何时需用 shared_ptr ?

• 程序不知道需要使用多少对象. 如使用窗口类, 使用 shared_ptr 为了多个对象共享相同底层数据.

std::vector<std::string> v1; // 一个空的 vector
// 在某个新的作用域中拷贝数据到 v1 中
{std::vector<std::string> v2;v2.push_back("a");v2.push_back("b");v2.push_back("c");v1 &＃61; v2;
} // 作用域结束时 v2 被销毁, 数据被拷贝到 v1 中


• 程序不知所需对象的准确类型.
• 程序需要在多个对象间共享数据.

参考链接

• 添加链接描述

#include
#include
using namespace std;int main()
{cout << sizeof(shared_ptr<vector<int>>) << endl;
}