1、shared_ptr中的px出现原因

创新互联公司服务项目包括尤溪网站建设、尤溪网站制作、尤溪网页制作以及尤溪网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，尤溪网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到尤溪省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！

  方便对其数据空间的管理，取值和获取地址将极大的方便我们的操作。

2、解决析构函数

  避免内存空间的泄漏。new出来的空间都没有释放掉！

  释放拥有权靠的是引用计数。

~shared_count(){ 
    if(pi){  //判断所指父类是否为空
        pi->release(); //释放new出来的对象和外部new出来的空间
    }
}
////////////////////////////////////////////////////////////////////////
public:
    virtual void dispose() = 0; //纯虚函数
    void release(){  //在sp_counted_base中
        if(--use_count_ == 0){ //判断use_count是否为0
            dispose();  //因为虚函数，所以子类中实现
            delete this; //先调用析构函数，在释放this指向的空间
        }    
    }
///////////////////////////////////////////////////////////////////////
public:
    void dispose(){
        delete px_; //释放外部new出来的空间
    }

因为要级联释放空间，所以sp_counted_base的析构函数必须是虚函数，才能先调用子类的析构，最后调用自己的析构函数。

结果如下：

use_count和unique函数的实现比较简单

3、拷贝构造和赋值语句

  此时应当相当于浅拷贝，use_count加1即可！模型如下：

  此时应在shared_ptr和shared_count进行浅拷贝，并在shared_count中加入方法，

    shared_count(shared_count const &r) : pi(r.pi){
        if(pi){
            pi->add_ref_copy(); //在父类中实现这个方法，只要让++use_count_即可！
        }
    }

  赋值语句，关键调用swap函数，的认真思考，画画图就好理解多了(前面已经写过这个了)。

  这个赋值语句写的真的很好，既让use_count_加1，又可以让原先的空间符合情况的释放。

    shared_ptr& operator=(shared_ptr const &r){
        if(this != &r){
            this_type(r).swap(*this);//调用拷贝构造，先创建一个无名临时的对象，
        }                         //因为调用了拷贝构造，所以在shared_count中调用方法,
        return *this;             //会让use_count_加1的。
    }
//////////////////////////////////////////////////////////////////////////////////////
    void swap(shared_ptr &other){
        std::swap(px, other.px); //指针的交换
        pn.swap(other.pn);
    }

3、shared_ptr的模拟部分：

#ifndef _CONFIG_H_
#define _CONFIG_H_

#include
using namespace std;

//#define DISPLAY

#endif
////////////////////////////////////////////////////////////////////////////////////////
#ifndef _SHARED_PTR_H_
#define _SHARED_PTR_H_

#include"shared_count.h"

template
class shared_ptr{
    typedef shared_ptr this_type;
public:
    shared_ptr(T *p = 0) : px(p), pn(p){
#ifdef DISPLAY
        cout<<"Create shared_ptr object!"< const &r) : px(r.px), pn(r.pn){}
    shared_ptr& operator=(shared_ptr const &r){
        if(this != &r){
            this_type(r).swap(*this);//调用拷贝构造，先创建一个无名临时的对象
        }
        return *this;
    }
    ~shared_ptr(){
#ifdef DISPLAY
        cout<<"Free shared_ptr object"<()const{
        return get();
    }
    T* get()const{
        return px;
    }
public:
    long use_count()const{
        return pn.use_count();
    }
    bool unique()const{
        return pn.unique();
    }
    void reset(T *p){
        this_type(p).swap(*this);
    }
    void swap(shared_ptr &other){
        std::swap(px, other.px); //指针的交换
        pn.swap(other.pn);
    }
private:
    T *px;
    shared_count pn;
};

#endif
////////////////////////////////////////////////////////////////////////////////////////////
#ifndef _SHARED_COUNT_H_
#define _SHARED_COUNT_H_

#include"config.h"
#include"sp_counted_base.h"
#include"sp_counted_impl_xx.h"

class shared_count{
public:
    template  //此时类型不定，写模板函数
        shared_count(T *p) : pi(new sp_counted_impl_xx(p)){
#ifdef DISPLAY
        cout<<"Create shared_cout object!"<add_ref_copy();
        }
    }
    ~shared_count(){
#ifdef DISPLAY
        cout<<"Free shared_count object"<release();
        }
    }
public:
    long use_count()const{
        return pi != 0 ? pi->use_count() : 0;
    }
    bool unique()const{
        return use_count() == 1;
    }
    void swap(shared_count &r){
        sp_counted_base *tmp = r.pi;
        r.pi = pi;
        pi = tmp;
    }
private:
    sp_counted_base *pi;
};

#endif
//////////////////////////////////////////////////////////////////////////////
#ifndef SP_COUNTED_BASE_H_
#define SP_COUNTED_BASE_H_

#include"config.h"

class sp_counted_base{  //抽象类
public:
    sp_counted_base() : use_count_(1){
#ifdef DISPLAY
        cout<<"Create sp_counted_base object"<
class sp_counted_impl_xx : public sp_counted_base{
public:
    sp_counted_impl_xx(T *p) : px_(p){
#ifdef DISPLAY
        cout<<"Create sp_counted_impl_xx object"<
#include"shared_ptr.h"
using namespace std;

int main(void){
    int *p = new int(10);
    shared_ptr ps(p);

    cout< ps1 = ps;
    cout< ps2;
    ps2 = ps;
    cout<
以上就是对shared_ptr的部分源码剖析的理解了。
4、删除器
  删除器d可以是一个函数对象(是一个对象，但是使用起来像函数)，也可以是一个函数指针；
  可以根据自己定义的方式去管理(释放)内存空间。
  有2个特性：函数对象 operator()进行了重载
删除器的使用，调用系统的：
#include
#include
using namespace std;
using namespace boost;

void My_Deleter(int *p){ //删除器
    cout<<"HaHa:"< ps(p, My_Deleter);
}
  回过头来，对自己的空间进行释放，定义自定义的删除器。不采用默认方式释放，而是
采用自己的方式释放！
删除器自己模拟部分代码：
public:
    template
        shared_ptr(Y *p, D d) : px(p), pn(p, d){}//支持传递删除器
/////////////////////////////////////////////////////////////////////////////
    template
    shared_count(Y *p, D d) : pi(0){
        typedef Y* P;
        pi = new sp_counted_impl_pd(p, d);
    }
///////////////////////////////////////////////////////////////////////////
template
class sp_counted_impl_pd : public sp_counted_base{
public:
    sp_counted_impl_pd(P p, D d) : ptr(p), del(d){}
public:
    void dispose(){
        delete ptr;
    }
private:
    P ptr;
    D del;
};
//////////////////////////////////////////////////////////////////////////
#include
#include"shared_ptr.h"
using namespace std;


void My_Deleter(int *p){ //删除器
    cout<<"HaHa:"< ps(p, My_Deleter);
}
以上就是删除器实现的主要代码，是在shared_ptr中实现的。
            
            
                            

                分享标题：shared_ptr(下)删除器                

                路径分享：http://myzitong.com/article/phdiij.html