1、智能指针设计初衷:
智能指针实际是类,超过类的作用域后,析构函数会自动回收资源,为程序员管理申请的堆内存,避免内存泄漏
2、C++ 智能指针种类:
auto_ptr
(C++98 的⽅案,C11 已抛弃)采⽤所有权模式。auto_ptr构造时取得某个对象的所有权,在析构时释放该对象。我们实际上是创建一个auto_ptr<Type>类型的局部对象,该局部对象析构时,会将自身所拥有的指针空间释放,所以不会有内存泄露。auto_ptr不支持new 数组。
注意:不要使用auto_ptr 作为函数入参,因为函数的形参其实是拷贝,然而智能指针拷贝的过程,会导致其拥有权发生转移,你传入的实参拥有权会转移到拷贝后的形参上,形参在函数运行的生命周期结束后,就会析构,导致你之前实参拥有的(主程序的对象、内存)内存被释放,导致致命的执行错误。
结论:如果必须需要使用智能指针作为函数入参,使用const 引用
#include <iostream>
#include <memory>
using namespace std;
int main()
{
//auto_ptr 通过构造函数初始化
int*ptr1 = new (std::nothrow)int(4);
if (nullptr == ptr1)
{
cout<<"new failed !"<<endl;
return -1;
}
auto_ptr<int> a_ptr1(ptr1);
auto_ptr<int> a_ptr2(new int(5));
cout << "a_ptr1 data : "<<*a_ptr1 <<endl;
cout << "a_ptr2 data : "<<*a_ptr2 <<endl;
//一块内存只能由一个auto_ptr独享,拷贝构造或赋值时都会发生拥有权转移
//拷贝构造,a_ptr1失去对ptr1内存的所有权,a_ptr3拥有,负责内存的销毁
auto_ptr<int> a_ptr3(a_ptr1);
//赋值
a_ptr2 = a_ptr3;
//cout << "拷贝构造后 a_ptr1 data : "<<*a_ptr1 <<endl;
cout << "赋值后 a_ptr2 data : "<<*a_ptr2 <<endl;
//cout << "赋值后 a_ptr3 data : "<<*a_ptr3 <<endl;
//智能指针会默认初始化为0
auto_ptr<int> a_ptr4;
//禁止一个对象(内存)被多个auto_ptr拥有
/* int *data = new (std::nothrow)int(5);
auto_ptr<int> a_ptr5 = auto_ptr<int>(data);
auto_ptr<int> a_ptr6 = auto_ptr<int>(data);
cout << "a_ptr5 data : "<<*a_ptr5 <<endl;
cout << "a_ptr6 data : "<<*a_ptr6 <<endl; */
//常用函数
//get()获取auto_ptr拥有的内存(对象)的地址
int *data1 = new (std::nothrow)int(5);
auto_ptr<int> a_ptr7(data1);
cout << "the add of data1: " << data1 << endl;
cout << "the get() return of a_ptr7: " << a_ptr7.get() << endl;
//reset 重置auto_ptr拥有的内存(对象),重置的过程会释放auto_ptr先拥有的内存int(5)
cout << "the data of a_ptr7: " << *a_ptr7 << endl;
a_ptr7.reset(new (std::nothrow)int(6));
cout << "the data of a_ptr7 after reset: " << *a_ptr7 << endl;
return 0;
}
unique_ptr
unique_ptr 实现独占式拥有或严格拥有概念,保证同⼀时间内只有⼀个智能指针可以指向该对 象。它对于避免资源泄露特别有⽤。
#include <iostream>
#include <memory>
using namespace std;int main()
{/* unique_ptr */
int *p = new int(5);
unique_ptr<int>p1(p);
//std::unique_ptr<int>p2=p1;// 编译会出错
//move转移所有权, 现在那块内存归p3所有, p1成为无效的指针.
unique_ptr<int>p3=move(p1);
cout << "the add of p: " << p <<" | "<< " the data of p: " << *p << endl;
cout << "the add of p3: " << p3.get() <<" | "<< " the data of p3: " << *p3 <<endl;
//reset释放内存.
p3.reset();
//无效
//p1.reset();//默认初始为nullptr
unique_ptr<int>p4;
cout << "the add of p4 : " << (p4 ? "not nullptr" : "nullptr") << endl;//release释放智能指针的内存拥有权
int *a = new int(4);
p4 = (unique_ptr<int>)(a);
int *p5 = p4.release();
cout << "the add of a: " << a <<" | "<< "the data of a: " << *a <<endl;
cout << "the add of p5: " << p5 <<" | "<< "the data of p5: " << *p5 <<endl;
delete p5;
p5 = nullptr;//swap交换内存
unique_ptr<int> p6(new int (6));
unique_ptr<int> p7(new int (7));
p6.swap(p7);
cout << "the data of p6: " << *p6 << " | " <<"the data of p7: " << *p7 << endl;return 0;
}
shared_ptr
共享型智能指针,一块内存可被多个shared_ptr 引用,内部采用引用计数管理,计数为0时,则删除智能指针,回收资源。
注意:
1、不要使用同一个原始指针构造 shared_ptr,如果需要构建多个shared_ptr管理同一块内存,使用一个已存在的shared_ptr 进行创建。
2、shared_ptr 不能相互引用,会导致引用计数无法下降到0,资源无法被回收,造成内存泄漏
#include <iostream>
#include <memory>
using namespace std;
int main()
{
/* shared_ptr */
//使用 make_shared 创建空对象
shared_ptr<int> sha_p1 = make_shared<int>();
*sha_p1 = 1;
//use_count 查看内存引用计数
cout << "the use count = " << sha_p1.use_count() << endl; //1
//无参reset 计数重置为0
sha_p1.reset();
cout << "the use count = " << sha_p1.use_count() << endl; //0
//有参reset 计数为1
sha_p1.reset(new int(2));
cout << "the use count = " << sha_p1.use_count() << endl; //1
//置nullptr 计数为0
sha_p1 = nullptr;
cout << "the use count = " << sha_p1.use_count() << endl; //0
//不要用原始指针初始化多个智能指针
int *num = new int(3);
shared_ptr<int> sha_p2(num);
shared_ptr<int> sha_p3(sha_p2); // 正确使用方法
shared_ptr<int> sha_p4(num); // 不推荐
//假如使用原始指针num创建了sha_p2,sha_p4,当sha_p2超出作用域时会调用
//delete释放num内存,此时num成了悬空指针,当sha_p4超出作用域再次delete的时候就可能会出错
cout << "sha_p2 use count = " << sha_p2.use_count() << endl; // 输出 2
cout << "sha_p3 use count = " << sha_p3.use_count() << endl; // 输出 2
cout << "sha_p4 use count = " << sha_p4.use_count() << endl; // 输出 1
return 0;
}
weak_ptr
weak_ptr 是为了配合 shared_ptr 而引入的一种智能指针,可以解决shared_ptr 循环引用的问题,weak_ptr,由于是弱共享,weak_ptr 的创建并不会影响 shared_ptr 的引用计数值。
#include <iostream>
#include <memory>
using namespace std;
class ClassB;
class ClassA
{
public:
ClassA() { cout << "ClassA Constructor Success" << endl; }
~ClassA() { cout << "ClassA Destructor Success" << endl; }
weak_ptr<ClassB> pb; // 在A中引用B
};
class ClassB
{
public:
ClassB() { cout << "ClassB Constructor Success" << endl; }
~ClassB() { cout << "ClassB Destructor Success" << endl; }
weak_ptr<ClassA> pa; // 在B中引用A
};
int main()
{
/* weak_ptr*/
shared_ptr<ClassA> ca_ptr = make_shared<ClassA>();
shared_ptr<ClassB> cb_ptr = make_shared<ClassB>();
ca_ptr->pb = cb_ptr;
cb_ptr->pa = ca_ptr;
cout << "the use count of ca_ptr = " << ca_ptr.use_count() << endl; //1
cout << "the use count of cb_ptr = " << cb_ptr.use_count() << endl; //1
//对象A 、B都被析构了
return 0;
}