一、前言
- C/C++最让人诟病的特性之一:内存泄漏。因此如java、C#等语言都提供了内置内存分配与释放功能,屏蔽了指针。自动分配内存还是手动分配内存都有利有弊,而指针>智能指针为解决内存泄漏问题应运而生。
- 内存泄漏的案例:如我们new了一个对象在堆区开辟了空间,需要在一定位置将其delete释放空间,但是程序可能在未执行到delete语句时就已经跳转或返回了,从而造成内存泄漏。而如果使用指针>智能指针,因为指针>智能指针本质是一个类,当超过类的作用域时,类会自动调用析构函数释放内存,从而避免内存泄漏。
- 内存泄漏,如遇到try/catch异常处理模块,发生异常时可能并不会delete销毁内存。
二、指针>智能指针
- 最早提出的指针>智能指针是std::auto_ptr,在C++03版本标准库第一次引入。当时只有std::auto_ptr,然而在C++11,std::auto_ptr被抛弃,引入了:std::unique_ptr、std::share_ptr、std::weak_ptr。
- 指针>智能指针:头文件 #include
三、auto_ptr
class Test
{
public:
Test(string s)
{
str = s;
cout << "Test create" << endl;
}
~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指针>智能指针其实是个模板类,创建的方式和模板类似,
<>
里写入参数,在这里将之前的类Test
写入,创建Test的指针>智能指针。创建一个指针>智能指针后,就可以像创建类的指针一样调用Test对象了。 - 指针>智能指针ptest调用Test类的方法时用
->
,而调用指针>智能指针本身的方法如get、reset时使用.
。 - reset方法,可以将指针>智能指针指向一个新的空间,原有空间将释放。
#include <iostream>
using namespace std;
int main()
{
auto_ptr<Test> ptest(new Test("123"));
ptest->print();
ptest.get()->print();
cout << "######################" << endl;
ptest->setStr("hello ");
ptest->getStr() += "world!";
(*ptest).print();
cout << "######################" << endl;
ptest.reset(new Test("123"));
ptest->print();
return 0;
}
指针>智能指针赋值
- 创建两个指针>智能指针ptest1和ptest2,将ptest1赋值给ptest2,ptest2 = ptest1,对于auto_ptr来说,ptest2将接管ptest1的内存管理,ptest1指针变为NULL,ptest2原来的内存析构。注意:判断一个指针>智能指针是否为空使用if(ptest1.get() == NULL)。
- ptest.release()将ptest的赋值设为空,但是不释放资源,可用reset释放。
int main()
{
auto_ptr<Test> ptest1(new Test("123"));
auto_ptr<Test> ptest2(new Test("456"));
ptest2 = ptest1;
ptest2->print();
if (ptest1.get() == NULL)
{
cout << "ptest1 is NULL" << endl;
}
return 0;
}
四、unique_ptr
- unique_ptr,用来取代auto_ptr的产物。
- unique_ptr和auto_ptr十分相似,不过不能使用两个指针>智能指针直接赋值操作,需要使用std::move()函数。
- 可直接用if(ptest == NULL)来判断是否为空指针。
- 可以使用swap交换两个元素
int main()
{
unique_ptr<Test> ptest1(new Test("123"));
unique_ptr<Test> ptest2(new Test("456"));
ptest1->print();
ptest2->print();
ptest1.swap(ptest2);
ptest1->print();
ptest2->print();
ptest2 = std::move(ptest1);//不可直接ptest2 = ptest1
if (ptest1 == NULL)
cout << "ptest1 is NULL" << endl;
Test* p = ptest2.release();
p->print();
ptest1.reset(p);
ptest1->print();
return 0;
}
五、share_ptr
-
从名字share可见资源是共享的,通过计数机制表明资源被几个指针共享。当进行拷贝或赋值操作时,每个shared_ptr都会记录有多少个其他shared_ptr指向相同的对象。
-
通过函数use_count()查看资源所有者的个数。
-
调用reset函数时,当前指针会释放资源所有权,计数减一。当计数为0,资源会被释放。即当指向一个对象的最后一个shared_ptr被销毁时,shared_ptr类会自动销毁此对象。
int main()
{
shared_ptr<Test> ptest1(new Test("123"));
shared_ptr<Test> ptest2 = make_shared<Test>("456");
cout << ptest2->getStr() << endl;
cout << ptest2.use_count() << endl;
cout << "######################" << endl;
ptest1 = ptest2; //"456"加1,"123"销毁
//两者都是"456"
cout << ptest2->getStr() << endl;
cout << ptest1->getStr() << endl;
cout << ptest1.use_count() << endl;
cout << ptest2.use_count() << endl;
cout << "######################" << endl;
ptest1.reset();
cout << ptest2.use_count() << endl;
ptest2.reset();
cout << ptest2.use_count() << endl;
return 0;
}
- 可以看到,ptest1 = ptest2时,ptest1对应的"123"销毁,ptest1和ptest2共享"456"对应的内存,这和之前的auto_ptr和unique_ptr不一样,之前的两个指针>智能指针的在赋值后ptest1变为空。
六、weak_ptr
-
weak_ptr用于解决shared_ptr相互引用时的死锁问题,即两个指针的引用个数永远不会减小到0,资源不会被释放。
-
weak_ptr是对对象的一种弱引用,不会增加对象的引用计数,可以和shared_ptr之间互相转换,shared_ptr可以直接赋值给它,它可以通过调用lock函数来获得shared_ptr。
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;
}
- 通过结果,可以看到,最后两者都没有调用析构函数,也就说资源没有被释放。原因在于,在fun()函数中pa和pb互相引用,两个资源的引用个数为2;跳出fun()函数时,指针>智能指针pa、pb析构两个资源的引用减一,但是两者资源依旧是1,也就是类A和类B中的两个资源引用没有减1,从而造成内存泄漏。
解决互相引用问题
解决办法是,其中一个类的指针>智能指针用weak_ptr替代。比如,将A的shared_ptr< B > pb改为weak_ptr< B > pb。
- 开始,资源B的引用为1,资源A的引用为2;
- 跳出fun()函数时,pb析构,B的引用减一为0,B资源释放,pb中的指针>智能指针资源A也被释放,A - 1 = 1;
- 这时候A等于1,pa再析构后,A - 1=0,A资源得到释放。
class B;
class A
{
public:
weak_ptr<B> pb;
~A()
{
cout << "A delete" << endl;
}
};
class B
{
public:
shared_ptr<A> pa;
~B()
{
cout << "B delete" << endl;
}
void show()
{
cout << "hello" << 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;
shared_ptr<B> test = pa->pb.lock();
test->show();
}
七、总结
从以上各种指针>智能指针的用法可以总结,我们使用指针>智能指针其实是利用其对象的性质,对于指针>智能指针本身并不需要new,而对需要操作的元素new出空间。而指针>智能指针在函数结束后就会调用析构函数,new出的元素也会被释放,从而解决了内存泄漏的问题。