C++里面的四个智能指针分别是:auto_ptr,shared_ptr,weak_ptr,unique_ptr,其中后三个是C++11支持的,第一个auto_ptr已经被弃用。为什么要使用智能指针?智能指针的作用是管理一个指针,因为存在着以下这种情况:申请的空间在函数结束时忘记释放,造成内存泄漏。使用智能指针可以很大程度上的避免这个问题,因为智能指针就是一个类,当超出了类的作用域时,类会自动调用析构函数,析构函数会自动释放内存空间,不需要手动释放内存空间。
智能指针主要用于管理在堆上分配的内存,它将普通的指针封装为一个栈对象。当栈对象的生存周期结束后,会在析构函数中释放掉申请的内存,从而防止内存泄漏。C++11中最常用的智能指针类型为shared_ptr,它采用引用计数的方法,记录当前内存资源被多少个智能指针引用。该引用计数的内存在堆上分配。当新增一个智能指针时引用计数加1,当智能指针过期时引用计数减1。只有引用计数为0时,智能指针才会自动释放引用的内存资源。对shared_ptr进行初始化时不能将一个普通指针直接赋值给智能指针,因为一个是指针,一个是类,可以通过make_shared()函数或者通过构造函数传入普通指针,并可以通过get()函数获得普通指针。
auto_ptr
auto_ptr<string> p1(new string("Hello World !"));
auto_ptr<string> p2;
p2 = p1; //quto_ptr不会报错
此时不会报错,p2剥夺了p1的所有权,但是当程序运行时访问p1将会报错。所以auto_ptr的缺点就是存在潜在的内存崩溃问题。
unique_ptr
unique_ptr实现独占式拥有或严格拥有概念,保证同一时间内只有一个智能指针可以指向该对象。它对于避免资源泄露(例如,以new创建对象后因为发生异常而忘记调用delete)非常有用。
unique_ptr<string> p3(new string("Hello world !"));
unique_ptr<string> p4;
p4 = p3; //会报错
编译器认为p4 = p3非法,避免了p3不再指向有效数据的问题。因此,unique_ptr比auto_ptr更安全。另外,unique_ptr还有一个比较好的一点:当程序试图将一个unique_ptr赋值给另一个时,如果源unique_ptr是个临时右值,编译器允许这么做;如果源unique_ptr将存在一段时间,编译器将禁止这么做,比如
unique_ptr<string> p1(new string("Hello world !"));
unique_ptr<string> p2;
p2 = p1; //不允许
unique_ptr<string> p3;
p3 = unique_ptr<string>(new string("Hello world !")); //允许
其中p2 = p1之后留下悬挂的unique_ptr(p1),这可能导致危害。而p3并不会留下悬挂的unique_ptr,因为它调用了unique_ptr的构造函数,该构造函数创建的临时对象在其所有权让给p3后就会被销毁。这种随情况而定的行为表明,unique_ptr优于允许两种赋值的auto_ptr。
如果确实想执行类似于p2 = p1的操作,要安全的重用这种指针,可给它赋新值。C++有一个标准库函数std::move()函数,能够让一个unique_ptr赋给另一个。
unique_ptr<string> p1,p2;
p1 = demo("Hello");
p2 = move(p1);
p1 = demo("world");
cout << *p1 << *p2 << endl;
shared_ptr
shared_ptr实现共享式拥有概念。多个智能指针可以指向相同对象,该对象和其相关资源会在最后一个引用被销毁的时候释放。从名字就可以看出资源可以被多个指针共享,它使用计数机制来表明资源被几个指针共享。可以通过成员函数use_count()函数来查看资源的所有者个数。除了可以通过new来构造,还可以通过传入auto_ptr、unique_ptr、weak_ptr来构造。当我们调用release()函数时,当前指针会释放资源所有权,计数减1,当计数等于0时,资源会被释放。
shared_ptr是为了解决auto_ptr在对象所有权上独占式的局限性,在使用计数的机制上提供了可以共享所有权的智能指针。成员函数有:
use_count() 返回引用计数的个数
unique() 返回是否是独占所有权
swap() 交换两个share_ptr对象(即交换所拥有的对象)
reset() 放弃内部对象的所有权或拥有对象的变更,会引起原有对象的引用计数的减少
get() 返回内部对象,由于已经重载了()方法,因此和直接使用是一样的。如shared_ptr<int> sp(new int(1));sp与sp.get()是等价的。
weak_ptr
weak_ptr是一种不控制对象生命周期的智能指针,它指向一个shared_ptr的管理对象。进行该对象的内存管理的是那个强引用shared_ptr。weak_ptr只是提供了对管理对象的一个访问手段。weak_ptr设计的目的是为了配合shared_ptr而引入的一种智能指针,来协助shared_ptr工作。它只可以从一个shared_ptr或另一个weak_ptr对象构造,它的构造和析构不会引起计数的增加或减少。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" << endl;
}
};
class B
{
public:
shared_ptr<A> pa_;
~B()
{
cout << "B" << 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;
}
以上代码中可以看出,fun()函数中pa与pb相互引用,两个资源的引用计数为2,当要跳出函数时,智能指针pa,pb析构时两个资源引用计数会减1,但是两者引用计数还是为1,导致跳出函数是资源还没有被释放(A、B的析构函数没有被调用),如果把其中一个改为weak_ptr就可以了,我们把类A里面的shared_ptr pb_改为weak_ptr pb_,这样的话,资源B的引用开始就只有1,当pb析构时,B的计数变为0,B得到释放,B释放的同时也会使A的计数减1,同时pb析构时使A的计数减1,那么A的计数为0,A得到释放。需要注意的是我们不能通过weak_ptr直接访问对象,比如B对象中有一个方法print(),我们不能使用pa->pb_->print()来访问,因为pb_是一个weak_ptr,应该先把它转化为shared_ptr,如shared_ptr p = pa->pb_.lock();p->print();。
智能指针的内存泄露及解决
当两个对象相互使用一个shared_ptr成员变量指向对方,会造成循环引用,使引用计数失效,从而导致内存泄漏。如下:
#include <memory>
#include <iostream>
using namespace std;
class Child;
class Parent
{
private:
std::shared_ptr<Child> childptr;
public:
void setchild(std::shared_ptr<Child> child)
{
this->childptr = child;
}
void fun()
{
if (this->childptr.use_count())
{
}
}
~Parent();
};
class Child
{
private:
std::shared_ptr<Parent> parentptr;
public:
void setparent(std::shared_ptr<Parent> parent)
{
this->parentptr = parent;
}
void fun()
{
if (this->parentptr.use_count())
{
}
}
~Child();
};
int main()
{
std::weak_ptr<Parent> wpp;
std::weak_ptr<Child> wpc;
{
std::shared_ptr<Parent> p(new Parent);
std::shared_ptr<Child> c(new Child);
p->setchild(c);
c->setparent(p);
wpp = p;
wpc = c;
cout << p.use_count() << endl;
cout << c.use_count() << endl;
}
cout << wpp.use_count() << endl;
cout << wpc.use_count() << endl;
return 0;
}
上述代码中,Parent有一个shared_ptr类型的成员指向Child,而Child也有一个shared_ptr类型的成员指向Parent。然后在创建Child和Parent对象时也使用了智能指针c和p,随后将c和p分别又赋值给Child的智能指针成员parent和Parent的智能指针成员child,从而形成了一个循环引用,导致内存泄漏。而为了解决循环引用导致的内存泄漏,引入了weak_ptr弱指针,weak_ptr的构造函数不会修改引用计数的值,从而不会对对象的内存进行管理,其类似一个普通指针,但不指向引用计数的共享内存,但是其可以检测到所管理的对象是否已经被释放,从而避免非法访问。