c++ 智能指针
c++ 有三种智能指针：
- shared_ptr
- weak_ptr
- unique_ptr
头文件
关于 auto_ptr 指针
C++98 提供了 auto_ptr 模板的解决方案, 在 c++11 被弃用，c++17中彻底移除，用 unique_ptr 代替
auto_ptr 被弃用的主要原因：
1.复制或者赋值都会改变资源的所有权，在STL容器中有重大风险
auto_ptr<string> p1(new string("I'm P1!"));
auto_ptr<string> p2(new string("I'm P2."));
vector<auto_ptr<string>> vec;
// 必须使用move修饰成右值，才可以进行插入容器中
vec.push_back(move(p1));
vec.push_back(move(p2));
cout << "vec[0]：" << *vec.[0] << endl; // 输出：I'm p1
cout << "vec[1]：" << *vec[1] << endl; // 输出：I'm p2
// p2赋值给p1后，首先p1会先将自己原先托管的指针释放掉，然后接收托管p2所托管的指针，
// 然后p2所托管的指针指向NULL，也就是p1托管了p2托管的指针，而p2放弃了托管。
p1 = p2;
// 风险来了：
vec[0] = vec[1];
cout << "vec[0]：" << *vec[0] << endl; // 输出: I'm p2
cout << "vec[1]：" << *vec[1] << endl; // ERROR, vec[1] 此时指向 nullptr
2.不支持对象数组的内存管理
auto_ptr<int[]> array(new int[5]); // ERROR, 不能这样定义
unique_ptr
C++11用更严谨的 unique_ptr 取代了auto_ptr。
unique_ptr 用法：
uniquer_ptr 是独占指针，只能有一个 unique_ptr 指针指向某个对象
通过指针占有并管理另一对象，并在 unique_ptr 离开作用域时释放该对象。
unique_ptr 可以不占有对象，此时 unique_ptr 为空
unique_ptr 有两个版本：
- 管理单个对象（例如以 new 分配）
- 管理动态分配的对象数组（例如以 new[] 分配）
类可以移动构造 (MoveConstructible) 和 移动赋值 (MoveAssignable)；不能复制构造 (CopyConstructible) 和 复制赋值 (CopyAssignable) 。(只能有一个 unique_ptr 指针指向某个对象)
构造方式
#include 注意：
只有非 const 的 unique_ptr 能转移被管理对象的所有权给另一 unique_ptr 。若对象的生存期为 const unique_ptr 所管理，则它被限定在创建指针的作用域中。
shared_ptr
共享指针，是为多个所有者可能必须管理对象在内存中的生命周期的方案设计。 在初始化一个 shared_ptr 之后，可复制它，按值将其传入函数参数，然后将其分配给其他 shared_ptr 实例。 所有实例均指向同一个对象，并共享对一个“控制块”（每当新的 shared_ptr 添加、超出范围或重置时增加和减少引用计数）的访问权限。 当引用计数达到零时，控制块将删除内存资源和自身。
简单实现 shared_ptr
#include weak_ptr
为了解决 shared_ptr 循环引用的问题而引入。
Weak_ptr允许共享，但不拥有一个对象。 它的对象是由shared_ptr创建的
class B;
class A {
public:
shared_ptr<B> _b;
A() { cout << "constuctor A" << endl; }
~A() { cout << "deconstuctor A" << endl; }
};
class B {
public:
shared_ptr<A> _a;
B() { cout << "constuctor B" << endl; }
~B() { cout << "deconstuctor B" << endl; }
};
int main()
{
shared_ptr<A> aPtr = make_shared<A>();
shared_ptr<B> bPtr = make_shared<B>();
cout << aPtr.use_count() << endl; // 输出 1
cout << bPtr.use_count() << endl; // 输出 1
return 0;
}
//输出
constuctor A
constuctor B
1
1
deconstuctor B
deconstuctor A
此时 A 和 B 正常析构。
int main()
{
shared_ptr<A> aPtr = make_shared<A>();
shared_ptr<B> bPtr = make_shared<B>();
cout << aPtr.use_count() << endl; // 输出 1
cout << bPtr.use_count() << endl; // 输出 1
aPtr->_b = bPtr;
bPtr->_a = aPtr;
cout << aPtr.use_count() << endl; // 输出 2
cout << bPtr.use_count() << endl; // 输出 2
return 0;
}
// 输出
constuctor A
constuctor B
1
1
2
2
没有调用 A 和 B 的析构函数。aPtr 和 bPtr 的引用计数都为 2。
此时就会造成内存泄漏，所以需要 weak_ptr 指针
class B;
class A {
public:
weak_ptr<B> _b; // 这里把 shared_ptr 换成 weak_ptr
A() { cout << "constuctor A" << endl; }
~A() { cout << "deconstuctor A" << endl; }
};
class B {
public:
weak_ptr<A> _a; // 这里把 shared_ptr 换成 weak_ptr
B() { cout << "constuctor B" << endl; }
~B() { cout << "deconstuctor B" << endl; }
};
int main()
{
shared_ptr<A> aPtr = make_shared<A>();
shared_ptr<B> bPtr = make_shared<B>();
cout << aPtr.use_count() << endl; // 输出 1
cout << bPtr.use_count() << endl; // 输出 1
aPtr->_b = bPtr;
bPtr->_a = aPtr;
cout << aPtr.use_count() << endl;
cout << bPtr.use_count() << endl;
return 0;
}
// 输出
constuctor A
constuctor B
1
1
1
1
deconstuctor B
deconstuctor A