1、总括
2、std::auto_ptr
我们从代码开始分析:
void TestAutoPtr()
{
std::auto_ptr<Simple> my_memory(new Simple(1)); // 创建对象,输出:Simple:1
if (my_memory.get())
{ // 判断智能指针是否为空
my_memory->PrintSomething(); // 使用 operator-> 调用智能指针对象中的函数
my_memory.get()->info_extend = "Addition"; // 使用 get() 返回裸指针,然后给内部对象赋值
my_memory->PrintSomething(); // 再次打印,表明上述赋值成功
(*my_memory).info_extend += " other"; // 使用 operator* 返回智能指针内部对象,然后用“.”调用智能指针对象中的函数
my_memory->PrintSomething(); // 再次打印,表明上述赋值成功
}
} // my_memory 栈对象即将结束生命期,析构堆对象 Simple(1)
执行结果为:
Simple: 1
PrintSomething:
PrintSomething: Addition
PrintSomething: Addition other
~Simple: 1
上述为正常使用 std::auto_ptr 的代码,一切似乎都良好,无论如何不用我们显示使用该死的 delete 了。
其实好景不长,我们看看如下的另一个例子:
void TestAutoPtr2()
{
std::auto_ptr my_memory(new Simple(1));
if (my_memory.get())
{
std::auto_ptr my_memory2; // 创建一个新的 my_memory2 对象
my_memory2 = my_memory; // 复制旧的 my_memory 给 my_memory2
my_memory2->PrintSomething(); // 输出信息,复制成功
my_memory->PrintSomething(); // 崩溃
}
}
再来看另外一段代码:
#include
#include
using namespace std;
int main()
{
auto_ptr<int> ap1(new int);
*ap1 = 10;
if (true)
{
auto_ptr<int> ap2(ap1);
*ap2 = 20;
}
*ap1 = 100;
return 0;
}
最终上面两段代码都会导致崩溃,跟进 std::auto_ptr 的源码后,我们看到,第一段代码罪魁祸首是“my_memory2 = my_memory”,这行代码,my_memory2 完全夺取了 my_memory 的内存管理所有权,导致 my_memory 悬空,最后使用时导致崩溃。第二段代码为什么会崩溃呢?原因是因为,虽然有两个指针,但由于ap2是根据ap1拷贝构造出来的,所以他们只有一块内存空间,并且这块内存空间的所有者为ap2,ap1只有使用权,没有销毁权(即调用ap1的析构函数并不会释放空间),在上面的代码中,出了ap2的作用域后,就会调用ap2的析构函数释放空间,但是由于ap1并不知道空间已经释放,所有此时ap1就为“野指针”,再次访问就会造成程序崩溃。
所以,使用 std::auto_ptr 时,绝对不能使用“operator=”操作符及,拷贝构造。作为一个库,不允许用户使用,确没有明确拒绝[1],多少会觉得有点出乎预料。
看完 std::auto_ptr 好景不长的第一个例子后,让我们再来看一个:
void TestAutoPtr3() {
std::auto_ptr my_memory(new Simple(1));
if (my_memory.get()) {
my_memory.release();
}
}
执行结果为:
Simple: 1
看到什么异常了吗?我们创建出来的对象没有被析构,没有输出“~Simple: 1”,导致内存泄露。当我们不想让 my_memory 继续生存下去,我们调用 release() 函数释放内存,结果却导致内存泄露(在内存受限系统中,如果my_memory占用太多内存,我们会考虑在使用完成后,立刻归还,而不是等到 my_memory 结束生命期后才归还)。
正确的代码应该为:
void TestAutoPtr3() {
std::auto_ptr my_memory(new Simple(1));
if (my_memory.get()) {
Simple* temp_memory = my_memory.release();
delete temp_memory;
}
}
原来 std::auto_ptr 的 release() 函数只是让出内存所有权,这显然也不符合 C++ 编程思想。
总结: std::auto_ptr 可用来管理单个对象的对内存,但是,请注意如下几点:
(1) 尽量不要使用“operator=”以及拷贝构造。如果使用了,请不要再使用先前对象。
(2) 记住 release() 函数不会释放对象,仅仅归还所有权。
(3) std::auto_ptr 最好不要当成参数传递(因为出了函数作用域,空间就会销毁,实参就成为野指针)。
(4) 由于 std::auto_ptr 的“operator=”问题,有其管理的对象不能放入 std::vector 等容器中。
(5) ……
使用一个 std::auto_ptr 的限制还真多,还不能用来管理堆内存数组,这应该是你目前在想的事情吧,我也觉得限制挺多的,哪天一个不小心,就导致问题了。
由于 std::auto_ptr 引发了诸多问题,一些设计并不是非常符合 C++ 编程思想,所以引发了下面 boost 的智能指针,boost 智能指针可以解决如上问题。
让我们继续向下看。
3、boost::scoped_ptr
4、shared_ptr
void TestShared(shared_ptr<int> spt1)
{
cout << "usecount:" << spt1.use_count() << endl;
*spt1 = 10;
cout << "*spt1 = " << *spt1 << endl;
shared_ptr<int> spt2(spt1);
*spt2 = 20;
cout << "*spt2 = " << *spt2 << endl;
cout << "usecount:" << spt2.use_count() << endl;
shared_ptr<int> spt3 = spt1;
*spt3 = 30;
cout << "*spt3 = " << *spt3 << endl;
cout << "usecount:" << spt3.use_count() << endl;
return;
}
int main()
{
shared_ptr<int> spt1(new int);
cout << "usecount:" << spt1.use_count() << endl;
TestShared(spt1);
cout << "usecount:" << spt1.use_count() << endl;
return 0;
}
循环引用:
但是,如果仅仅只是这样,我们想想有可能还会出现下面的问题!
假设,有这样一个场景,p1,p2,分别指向双向链表的两个节点,在节点内,还有两个指针,pNext、pPre,这些指针的类型全都是shared_ptr管理,那么同一个节点,就会有两个shared_ptr管理,也就是说,p1和p2的引用计数都为2,假设函数Test()结束时,p1对象和p2对象就会销毁,但是由于此时还有p2指向的节点中的pPre指针指向p1指向的节点,即引用计数为1,所以并不能销毁,同理,p2指向的的节点也不能销毁,这样就会造成内存泄漏,那么,这样的问题该怎么解决呢?
struct ListNode
{
ListNode()
: pNext(NULL)
, pPre(NULL)
{}
shared_ptr pNext;
shared_ptr pPre;
int data;
};
void Test()
{
shared_ptr p1(new ListNode);
shared_ptr p2(new ListNode);
p1->pNext = p2;
p2->pPre = p1;
cout << "p1 usecount: " <cout << "p2 usecount: " <return;
}
int main()
{
Test();
return 0;
}
这里就引出了另一个指针weak_ptr,weak_ptr不对shared_ptr引用计数进行影响的“弱”指针,可以和shared_ptr搭配使用以解决资源的循环引用问题。当shared_ptr因引用计数为0而被释放时,相关的weak_ptr自动标记为无效。weak_ptr不能单独管理空间。