智能指针是什么
智能指针是
c++中有四个智能指针:auto_ptr、shared_ptr、weak_ptr、unique_ptr，其中后三个是c++11支持，并且第一个已经被c++11弃用。
智能指针是一个RAII(Resource Acquisition is initialization)类模型，用来动态的分配内存。当超出类的作用域时，类会自动调用析构函数，析构函数会自动释放资源。
举例:当我们写一个new语句时，一般会立即把delete语句也直接写入，但是不能避免程序还未执行到delete时就跳转或在函数没有执行到最后的delete语句就返回了，如果不在每一个可能跳转或返回的语句前释放资源，就会造成内存泄露，使用智能指针可以很大程度避免这个问题。
auto_ptr的类模板原型为：
templet<class T>
class auto_ptr {
explicit auto_ptr(X* p = 0) ;
...
};
- 定义一个类
class Test
{
public:
Test(string s)
{
str = s;
cout<<"Test creat\n";
}
~Test()
{
cout<<"Test delete:"<<str<<endl;
}
string& getStr()
{
return str;
}
void setStr(string s)
{
str = s;
}
void print()
{
cout<<str<<endl;
}
private:
string str;
};
- auto_ptr智能指针
- auto_ptr访问自己的成员函数用.，访问指向对象的成员时用->
- 对智能指针进行赋值时，ptest2 = ptest;。此时ptest2会接管ptest原来的内存管理权，ptest会变成空指针；如果ptest2原来不为空，则它会释放原来的资源。判断一个智能指针是否为空不能用if(ptest == NULL)，应该用if(ptest.get() == NULL)。
- auto_ptr的成员函数release，作用:把智能指针赋值为空，只释放对资源的所有权，原来指向的内存并不被释放。
- 若中途想释放资源，可以使用ptest.reset();，就不用等到智能指针被析构时释放。
int main()
{
auto_ptr<Test> ptest(new Test("123"));
auto_ptr<Test> ptest2(new Test("456"));
ptest2 = ptest;
ptest2->print();
if(ptest.get() == NULL)cout<<"ptest = NULL\n";
ptest->setStr("hello ");
ptest->print();
ptest.get()->print();
ptest->getStr() += "world !";
(*ptest).print();
ptest.reset(new Test("123")); //重新绑定指向的对象，原来的对象会被释放
ptest->print();
return 0;
}
- unique_ptr智能指针
- 独享所有权，拥有它指向的对象
- 无法进行复制构造，无法使两个unique_ptr指向同一个对象。应该用std::move()
- 保存指向某个对象的指针，当它本身被删除释放的时候，会使用给定的删除器释放它指向的对象。
4)可以用if(ptest == NULL)来判断是否空指针；
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();
ptest2 = std::move(ptest);//不能直接ptest2 = ptest
if(ptest == NULL)cout<<"ptest = NULL\n";
Test* p = ptest2.release();
p->print();
ptest.reset(p);
ptest->print();
ptest2 = fun(); //这里可以用=，因为使用了移动构造函数
ptest2->print();
return 0;
}
编译运行结果:
image.png
- share_ptr智能指针
- 资源可以被多个指针共享，使用计数机制表明资源被几个指针共享。通过成员函数use_count()来查看资源的所有者个数。
- 调用release()时，当前指针会释放资源所有权，计数减一。当计数等于0时，资源会被释放。
int main()
{
shared_ptr<Test> ptest(new Test("123"));
shared_ptr<Test> ptest2(new Test("456"));
cout<<ptest2->getStr()<<endl;
cout<<ptest2.use_count()<<endl;
ptest = ptest2;//"456"引用次数加1，“123”销毁
ptest->print();
cout<<ptest2.use_count()<<endl;//2
cout<<ptest.use_count()<<endl;//2
ptest.reset();
ptest2.reset();//此时“456”销毁
cout<<"done !\n";
return 0;
}
image.png
- weak_ptr智能指针
- 用来解决shared_ptr相互引用时的死锁问题，若两个shared_ptr相互引用，那么这两个指针的引用计数永远不可能下降为0，资源永远不会释放。
- 是对对象的一种弱引用，不会增加对象的引用计数，和shared_ptr之间可以相互转化，shared_ptr可以直接赋值给它，通过调用lock函数获得shared_ptr.
class B;
class A
{
public:
shared_ptr<B> pb_;
~A()
{
cout<<"A delete\n";
}
};
class B
{
public:
shared_ptr<A> pa_;
~B()
{
cout<<"B delete\n";
}
};
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;
}
上述fun函数中pa、pb之间相互引用，两个资源的引用计数为2，当要跳出函数时，智能指针pa、pb析构时两个资源引用计数会减一，但是两者引用计数还是为1，导致调出函数时资源没有被释放(A、B的析构函数没有被调用)。运行结果如下:
image.png
若把类A中的shared_ptr<B> pb_改为weak_ptr<B> pb_，资源B的引用开始只有1，当pb析构时，B的计数变为0，B得到释放，B释放的同时会使A的计数减一，同时pa析构时使A的计数减一，那么A的计数为0，A得到释放。编译运行结果如下:
image.png
- 是对对象的一种弱引用，不会增加对象的引用计数，和shared_ptr之间可以相互转化，shared_ptr可以直接赋值给它，通过调用lock函数获得shared_ptr.不能通过weak_ptr直接访问对象。
若B对象中有一个方法print()，不能通过如下方式访问
pa->pb_->print()
因为pb_是一个weak_ptr，应先把它转换为shared_ptr。
shared_ptr<B> p = pa->pb_.lock();
p->print();
