实现一个shared

C++11新特性的智能指针，是C++提供的最小垃圾回收的机制，shared_ptr是一个模板，可以管理指针，并实现自动释放的效果，抹开标准库中shared_ptr对于其它场景的思考, 其核心原理是引用——删除机制，即对于对象的清理在于其引用的个数进行判断，如果没有对象引用这个堆空间，即count=0的时候，就会将其释放。而unique_ptr是独占， 无法拷贝和赋值，只能以移动语义传播，下面是一个简化版的Shared_ptr和Unique_ptr模板，用于理解shared_ptr和unique_ptr的运行原理

• 支持get(), reset(), 解引用, ->运算符等常用API
• 没有考虑锁，只是用一个简单的counter字段来记录对Shared_ptr的引用

#include 

using namespace std;

template
class Shared_ptr{
public:

    template
    explicit Shared_ptr(ParametersTy&&... args) noexcept :ty(new StoreTy())
    {
        ty->t = new Ty(forward(args)...);
    }

    explicit Shared_ptr(Ty* p) noexcept :ty(new StoreTy())
    {
        ty->t = p;
    }

    Shared_ptr(const Shared_ptr& p) noexcept : ty(p.ty)
    {
        ty->count++;
    }

    ~Shared_ptr() noexcept
    {
        if(flag){
            ty->count--;
            if(ty->count == 0)
            {
                delete ty->t;
                delete ty;
            }
        }
    }

    size_t use_count() const { return ty->count; }

    Ty* get(){return ty->t;}

    void reset() noexcept
    {
        if(flag)
        {
            flag = false;
            ty->count--;
            if(ty->count == 0)
            {
                delete ty->t;
                delete ty;
            }
        }
    }

    Ty* operator->(){return ty->t;}

private:
    struct StoreTy{
        Ty *t{nullptr};
        int count{1};
    };

    bool flag{true};
    StoreTy* ty;
};

struct Value1{
    void print() { cout << "I am test type Value2n"; }
};

int main()
{
    Shared_ptr p;
    {
        auto p1 = p;
        p1->print();
        p.reset();
        cout<<"Use count "< 
Unique_ptr 
支持unique_ptr特性的模板
 
#include 

using namespace std;

template
class Unique_ptr{
public:
    template
    explicit Unique_ptr(ParameterTy&& ...args) noexcept : ty(new Ty(std::forward(args)...)){}

    Unique_ptr(Unique_ptr&& ptr) noexcept : ty(ptr.ty)
    {
        ptr.ty = nullptr;
    }

    ~Unique_ptr() noexcept {
        if(ty) delete ty;
        ty = nullptr;
    }

    Ty* get(){ return ty; }

    Ty operator*(){ return *ty; }

    Ty* operator->(){ return ty; }

    void reset() noexcept
    {
        if(ty) delete ty;
        ty = nullptr;
    }
private:
    Unique_ptr(const Unique_ptr& p) = delete;
    Unique_ptr operator=(const Unique_ptr& p) = delete;
    Ty* ty;
};

int main(){
    Unique_ptr a(10);
    Unique_ptr c = std::move(a);
    auto e = c;     // 报错，不支持拷贝和赋值
}