传说中的神器： shared_ptr/weak_ptr/scoped_ptr

ref page1 and page2

《Linux多线程服务端编程》称 shared_ptr/weak_ptr 之为神器。

in multi-threading programming, we sometime get core dump when delete som obj ,even if we has do the check:　　

if(obj)
delete obj;

　　However, core dump some out sometimes not always. My preview article has said something about this. And I avoid the problem by NOT delete them , using singleton pattern or ajust my logic.

Yet, this artile is the right solution for multi-threading programming.

#include <string.h>
#include <iostream>
#include <boost/shared_ptr.hpp>

class implementation
{
public:
~implementation(){std::cout<<"destroying implementation\n";}
void do_something(){std::cout<<"did something\n";}
};

void test()
{
boost::shared_ptr<implementation> sp1(new implementation);
std::cout<< "The Sample now has "<< sp1.use_count()<< " reference(sp1)\n";

//boost::shared_ptr<implementation> sp2(new implementation);
boost::shared_ptr<implementation> sp2 = sp1;
std::cout<< "The Sample now has "<< sp1.use_count()<< " reference(sp1)\n";
std::cout<< "The Sample now has "<< sp2.use_count()<< " reference(sp2)\n";

sp1.reset();
std::cout<<"After Reset sp1. The Sample now has "<<sp1.use_count()<< " reference\n";
std::cout<<"After Reset sp1. The Sample now has "<<sp2.use_count()<< " reference(sp2)\n";

sp2.reset();//will call for ~implementation
std::cout<<"After Reset sp2. The Sample now has "<<sp2.use_count()<< " reference\n";

}

int main(void)
{
test();
return 0;
}

=========================================================

For loop reference case , use weak_ptr

#include <string.h>
#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>

class parent;
class children;

typedef boost::shared_ptr<parent> parent_ptr;
typedef boost::shared_ptr<children> children_ptr;

class parent
{
public:
~parent(){std::cout<<"destroying parent\n";}
public:
boost::weak_ptr<children> child;    //changed from ori blog -- cause there was a complie error if use boost::weak_ptr<children> children
//    children_ptr children;
};

class children
{
public:
~children(){std::cout<<"destroying children\n";}
public:
boost::weak_ptr<parent> par;//changed from ori blog for the same reason
//    parent_ptr parent;
};
void test()
{
parent_ptr father(new parent());
children_ptr son(new children());

father->child = son;
son->par = father;
}

int main(void)
{
std::cout<<"begin test\n";
test();
std::cout<<"end test\n";
return 0;
}

I change the code above ref to the stackoverflow doc.

the difference between two of them:

强引用和弱引用

一个强引用当被引用的对象活着的话，这个引用也存在（就是说，当至少有一个强引用，那么这个对象就不能被释放）。boost::share_ptr就是强引用。

相对而言，弱引用当引用的对象活着的时候不一定存在。仅仅是当它存在的时候的一个引用。弱引用并不修改该对象的引用计数，这意味这弱引用它并不对对象的内存进行管理，在功能上类似于普通指针，然而一个比较大的区别是，弱引用能检测到所管理的对象是否已经被释放，从而避免访问非法内存。

the define of 引用计数 may be can ref to some python blog


As for scoped_ptr:

#include <string.h>
#include <iostream>
#include <boost/scoped_ptr.hpp>

class implementation
{
public:
~implementation(){std::cout<<"destroying implementation\n";}
void do_something(){std::cout<<"did something\n";}
};

void test()
{
boost::scoped_ptr<implementation> impl(new implementation());
impl->do_something();
}

int main(void)
{
std::cout<<"begin\n";
test();
std::cout<<"End\n";
return 0;
}

It will automatically destroy when leave.

EOF