C++:智能指针使用方法
image.png
0.什么是智能指针?
auto_ptr, shared_ptr, weak_ptr, unique_ptr这四个是常见的智能指针,其中后三个是c++11支持，并且第一个已经被c++11弃用。
1.有什么作用?
为了解决C++内存管理复杂的问题,解释如下:
(当我们写一个new语句时，一般就会立即把delete语句直接也写了，但是我们不能避免程序还未执行到delete时就跳转了或者在函数中没有执行到最后的delete语句就返回了，如果我们不在每一个可能跳转或者返回的语句前释放资源，就会造成内存泄露。使用智能指针可以很大程度上的避免这个问题，因为智能指针就是一个类，当超出了类的作用域是，类会自动调用析构函数，析构函数会自动释放资源.)
看来还是很有用的.
2.auto_ptr?
// auto_ptr
#if 1
#include <iostream>
#include <memory>
using namespace std;
class Test
{
public:
Test(string s)
{
str = s;
cout<<"Test create\n";
}
~Test()
{
cout<<"Test delete: "<<str<<endl;
}
string& get_str()
{
return str;
}
void set_str(string s)
{
str = s;
}
void print()
{
cout<<str<<endl;
}
private:
string str;
};
int main()
{
auto_ptr<Test> ptest(new Test("123"));//调用构造函数定义
//ptest.release();
ptest->set_str("hello");//调用set_str
ptest->print();//输出hello
ptest.get()->print();
ptest->get_str() += " world!";//hello world
(*ptest).print();
ptest.reset(new Test("123"));//先释放hello world,再创建123
ptest->print();
auto_ptr<Test> ptest2(new Test("456"));
ptest2 = ptest;
ptest2->print();
if (ptest.get() == NULL)//判断智能指针是否为空
{
cout << "ptest=NULL"<<endl;
}
return 0;
}
输出结果
如上面的代码,有：
1.智能指针可以像类的原始指针一样访问类的public成员，成员函数get()返回一个原始的指针，成员函数reset()重新绑定指向的对象，而原来的对象则会被释放.
2.注意当访问auto_ptr的成员函数时用的是“.”，当访问指向对象的成员时用的是“->”。我们也可用声明一个空智能指针auto_ptr<Test>ptest().
3.当我们对智能指针进行赋值时，如ptest2 = ptest，ptest2会接管ptest原来的内存管理权，ptest会变为空指针; 如果ptest2原来不为空，则它会释放原来的资源,再接管新的内存. 基于这个原因，应该避免把auto_ptr放到容器中，因为算法对容器操作时，有可能很会导致STL内部对容器实现了赋值传递操作，改变了容器内很多元素的值,使其为NULL。
3.判断一个智能指针是否为空不能使用if(ptest == NULL)，应该使用if(ptest.get() == NULL).
4.还有一个值得我们注意的成员函数是release，这个函数只是把智能指针赋值为空，但是它原来指向的内存并没有被释放，相当于它只是释放了对资源的所有权，析构函数没有被调用。
5.那么当我们想要在中途释放资源，而不是等到智能指针被析构时才释放，我们可以使用ptest.reset(); 语句。
3.unique_ptr?
unique_ptr是用于取代c++98的auto_ptr的产物,在c++98的时候还没有移动语义(move semantics)的支持,因此对于auto_ptr的控制权转移的实现没有核心元素的支持,但是还是实现了auto_ptr的移动语义,这样带来的一些问题是拷贝构造函数和复制操作重载函数不够完美,具体体现就是把auto_ptr作为函数参数,传进去的时候控制权转移,转移到函数参数,当函数返回的时候并没有一个控制权移交的过程,所以过了函数调用则原先的auto_ptr已经失效了.在c++11当中有了移动语义,使用move()把unique_ptr传入函数,这样你就知道原先的unique_ptr已经失效了.移动语义本身就说明了这样的问题,比较坑爹的是标准描述是说对于move之后使用原来的内容是未定义行为,并非抛出异常,所以还是要靠人肉遵守游戏规则.再一个,auto_ptr不支持传入deleter,所以只能支持单对象(delete object),而unique_ptr对数组类型有偏特化重载,并且还做了相应的优化,比如用[]访问相应元素等.
unique_ptr 是一个独享所有权的智能指针，它提供了严格意义上的所有权，包括：
1、拥有它指向的对象
2、无法进行复制构造，无法进行复制赋值操作。即无法使两个unique_ptr指向同一个对象。但是可以进行移动构造和移动赋值操作
3、保存指向某个对象的指针，当它本身被删除释放的时候，会使用给定的删除器释放它指向的对象
unique_ptr 可以实现如下功能：
1、为动态申请的内存提供异常安全
2、将动态申请的内存所有权传递给某函数
3、从某个函数返回动态申请内存的所有权
4、在容器中保存指针
5、auto_ptr 应该具有的功能
//unique_ptr
#if 1
#include<iostream>
#include<memory>
using namespace std;
class Test
{
public:
Test(string s)
{
str = s;
cout<<"Test create."<<endl;
}
~Test()
{
cout<<"Test delete:"<<str<<endl;
}
string& get_str()
{
return str;
}
void set_str(string s)
{
str = s;
}
void print()
{
cout<<str<<endl;
}
private:
string str;
};
unique_ptr<Test> fun()
{
return unique_ptr<Test>(new Test("789"));
}
int main()
{
unique_ptr<Test> ptest(new Test("123"));
unique_ptr<Test> ptest2(new Test("456"));
ptest->print();//123
//不能直接赋值ptest2=ptest,
//调用move后ptest2原来的对象会被释放;
//ptest2对象指向原本ptest对象的内存,
//输出Test delete 456
ptest2 = std::move(ptest);
//因为两个unique_ptr不能指向同一内存地址
//所以经过前面move后ptest会被赋值NULL,
//输出ptest=NULL
if(ptest == NULL)
cout<<"ptest=NULL"<<endl;
//release成员函数把ptest2指针赋值为空,
//但是并没有释放指针指向的内存;
//所以此时p指针指向原本ptest2指向的内存;
Test* p = ptest2.release();
p->print();//123
//重新绑定对象,原来的对象会被释放掉
//但是次ptest对象本来就被释放过了;
//所以这里就不会再调用析构函数了
ptest.reset(p);
//这里可以用=
//因为使用了移动构造函数,
//函数返回一个unique_ptr会自动调用移动构造函数.
ptest2 = fun();
ptest2->print();
return 0;
}
#endif
运行结果
比较:
1.unique_ptr 和 auto_ptr用法很相似，不过不能使用两个智能指针赋值操作，应该使用std::move;
2.unique_ptr可以直接用if(ptest == NULL)来判断是否空指针；
3.release、get、reset等用法也和auto_ptr一致，使用函数的返回值赋值时，可以直接使用=, 这里使用c++11 的移动语义特性。
4.另外注意的是当把它当做参数传递给函数时（使用值传递，应用传递时不用这样），传实参时也要使用std::move,比如foo(std::move(ptest))。
5.它还增加了一个成员函数swap用于交换两个智能指针的值.
4.share_ptr?
从名字share就可以看出了①资源可以被多个指针共享，它使用计数机制来表明资源被几个指针共享。可以通过成员函数use_count()来查看资源的所有者个数。②除了可以通过new来构造，还可以通过传入auto_ptr, unique_ptr,weak_ptr来构造。③当我们调用release()时，当前指针会释放资源所有权，计数减一。当计数等于0时，资源会被释放。
//share_ptr
#if 1
#include<iostream>
#include<memory>
using namespace std;
class Test
{
public:
Test(string s)
{
str = s;
cout<<"Test create"<<endl;
}
~Test()
{
cout<<"Test delete:"<<str<<endl;
}
string& get_str()
{
return str;
}
void set_str(string s)
{
str = s;
}
void print()
{
cout<<str<<endl;
}
private:
string str;
};
unique_ptr<Test> fun()
{
return unique_ptr<Test>(new Test("789"));
}
int main()
{
shared_ptr<Test> ptest(new Test("123"));//构造
shared_ptr<Test> ptest2(new Test("456"));
cout<<ptest2->get_str()<<endl;//456
//显示此资源被几个指针共享,输出1
cout<<ptest2.use_count()<<endl;
//456引用次数加1,123销毁,
//输出Test delete:123
ptest = ptest2;
ptest->print();//456
//该指针指向的资源被几个指针共享,输出2
//该指针指向的资源是456,456被ptest,ptest2,顾输出2
cout<<ptest2.use_count()<<endl;
cout<<ptest.use_count()<<endl;
//重新绑定对象,绑定一个空对象
//此时指针指向的对象还有其他指针指向,就不释放该内存空间,456引用-1
ptest.reset();
cout<<ptest2.use_count()<<endl;
//此时456销毁,此时指针指向的内存空间上的指针为0,就释放该内存,
//输出Test delete
ptest2.reset();
cout<<"done!"<<endl;
return 0;
}
#endif
运行结果
5.weak_ptr?
weak_ptr是用来解决shared_ptr相互引用时的死锁问题,如果说两个shared_ptr相互引用,那么这两个指针的引用计数永远不可能下降为0,资源永远不会释放。
它是对对象的一种弱引用，不会增加对象的引用计数，
和shared_ptr之间可以相互转化，shared_ptr可以直接赋值给它，它可以通过调用lock函数来获得shared_ptr。
#if 1
#include<iostream>
#include<memory>
using namespace std;
class B;
class A
{
public:
shared_ptr<B> pb_;
~A()
{
cout<<"A delete."<<endl;
}
};
class B
{
public:
shared_ptr<A> pa_;
~B()
{
cout<<"B delete."<<endl;
}
};
void fun()
{
shared_ptr<B> pb(new B());
shared_ptr<A> pa(new A());
pb->pa_ = pa;
pa->pb_ = pb;
cout<<pb.use_count()<<endl;
cout<<pa.use_count()<<endl;
}
int main()
{
fun();
return 0;
}
#endif
运行结果
分析
可以看到fun函数中pa ，pb之间互相引用，两个资源的引用计数为2，当要跳出函数时，智能指针pa，pb析构时两个资源引用计数会减一，但是两者引用计数还是为1，导致跳出函数时资源没有被释放（A B的析构函数没有被调用），
如果把其中一个改为weak_ptr就可以了，我们把类A里面的shared_ptr<B> pb_; 改为weak_ptr<B> pb_;
image.png
结果
这样的话，资源B的引用开始就只有1，当pb析构时，B的计数变为0，B得到释放，B释放的同时也会使A的计数减一，同时pa析构时使A的计数减一，那么A的计数为0，A得到释放。
