std::shared_ptr 是通过指针保持对象共享所有权的智能指针。多个 shared_ptr 对象可占有同一对象大概实现了一下，主要实现原理为，共享指针内部持有堆资源的指针以及引用计数的指针，通过对这两个指针的维护，达到多个共享对象对同一资源的控制

//smart_ptr_define.h
#ifndef __SMART_PTR_DEFINE_H__
#define __SMART_PTR_DEFINE_H__

#include <assert.h>

#define PTR_ASSERT(x) assert(x)

#define _SMART_PTR_BEGIN    namespace smartptr {
#define _SMART_PTR_END        }
#define _SMART_PTR    ::smartptr::

#endif

主要实现文件share_ptr.h

#ifndef __SHARE_PTR_H__
#define __SHARE_PTR_H__

#include <iostream>
#include "smart_ptr_define.h"

_SMART_PTR_BEGIN

template <class T>
struct default_deleter
{
    void operator()(T* ptr)
    {
        if (ptr != NULL)
        {
            delete ptr;
            ptr = NULL;
        }
    }
};

template <class T, class deleter = default_deleter<T> >
class shared_ptr
{
public:
    typedef shared_ptr<T, deleter> SHARE_PTR;

    shared_ptr()
    {
        m_ptr = NULL;
        m_iRefCount = NULL;
    }

    explicit shared_ptr(T* ptr)
    {
        if (ptr != NULL)
        {
            m_ptr = ptr;
            RefCountInit();
        }
    }

    shared_ptr(deleter d, T* ptr)
    {
        if (ptr != NULL)
        {
            m_ptr = ptr;
            m_deleter = d;
            RefCountInit();
        }
    }

    //拷贝构造
    shared_ptr(const SHARE_PTR& sh_ptr)
    {
        if (sh_ptr.m_ptr != NULL)
        {
            m_ptr = sh_ptr.m_ptr;
            m_deleter = sh_ptr.m_deleter;
            m_iRefCount = sh_ptr.m_iRefCount;

            RefCountIncrease();
        }
    }

    //赋值运算符
    SHARE_PTR& operator = (const SHARE_PTR& sh_ptr)
    {
        if (this != &sh_ptr)
        {
            RefCountDecrease();

            if (sh_ptr.m_ptr != NULL)
            {
                m_ptr = sh_ptr.m_ptr;
                m_deleter = sh_ptr.m_deleter;
                m_iRefCount = sh_ptr.m_iRefCount;

                RefCountIncrease();
            }
        }

        return (*this);
    }

    ~shared_ptr()
    {
        RefCountDecrease();
    }