区块链技术之数字签名简介

区块链技术之数字签名简介

 

区块链比特币中利用数字签名来保证数据在整个系统中不可篡改，并保证交易双方的身份真实可靠。数字签名使用了非对称加密技术和数字摘要技术，保证了数据在传输过程中的完整性、发送者身份真实不可假冒。非对称加密技术会产生一个公钥（publickey）和一个私钥（privatekey），公钥和私钥是一对，私钥保存在所有者手中，需要对外人保密不可让外人知道，公钥可以向其他信息接收方公开。如果用私钥对数据加密只有公钥才能解密，相反公钥加密过的数据，只有对应的私钥才能解密。

数字摘要是利用哈希函数把任意长度的信息变成固定长度的信息，哈希函数是单向生成体制，通过生成的哈希值不可逆向生成输入值。另外哈希函数是一种压缩映射，输出是固定长度的信息。

通过数字签名我们主要实现了：

1、接收方能通过发送方的公钥认证发送方的身份

2、通过私钥方式签名，别人伪造不了信息的签名

3、发送方也通过私钥签名抵赖不了对信息的签名

4、通过数字摘要技术保证了数据的完整性

5、哈希函数也保证了数据不可有任何篡改

数字签名流程图： 

1、在发送方通过哈希算法求出发送信息的哈希值

2、通过发送者的私钥对哈希值进行加密

3、把加密后的哈希值和待发送的信息一起发给接受者

4、接收者通过发送方的公钥对加密的哈希值进行解密，还原出哈希值1

5、对发送的信息进行哈希运算，生成哈希值2

6、比较哈希值1和哈希值2，如果相等证明信息无篡改、发送者身份确认，否则有人篡改了！

 

我不熟悉的set

同样的我着重介绍那些我不怎么用到的系列，同时，常用的我就点一下。

我们都知道set底层是用红黑树实现的，红黑树是一种已排序的树，所以我们通过迭代器来访问节点元素的时候，并不可以改变它，如果随意改变，那排序规则就乱套了。

讲API之前，现介绍一个 对组(pair) 的概念。

对组(pair)将一对值组合成一个值，这一对值可以具有不同的数据类型，两个值可以分别用pair的两个公有属性first和second访问。

创建对组的方法

一、使用拷贝构造

pair<string, int> pair1(string("name"), 20);
cout << pair1.first << endl; //访问pair第一个值
cout << pair1.second << endl;//访问pair第二个值

二、使用make_pair

pair<string, int> pair2 = make_pair("name", 30);
cout << pair2.first << endl;
cout << pair2.second << endl;

对组可以方便的将不同数据类型作为返回值，一次返回两个数值。

构造，赋值和大小操作

set<T> st;          //set默认构造函数。
set(const set &st); //拷贝构造函数
swap(set st);       //交换两个集合容器
size();             //返回容器中元素的数目
empty();            //判断容器是否为空

与前几篇说的一致。

插入与删除

pair<iterator,bool> insert(elem);  //在容器中插入元素。
void insert(beg,end)     //插入[beg,end)范围元素
iterator erase(pos);     //删除pos迭代器所指的元素，返回下一个元素的迭代器。
iterator erase(beg, end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
size_type erase(elem);   //删除容器中值为elem的元素。
void clear();            //清除所有元素

这边强调一下erase和insert:

关于erase:

• 既可以删除迭代器指向的元素，也可以删除指定的元素值。与list一致。
• 删除迭代器的时候返回指向的下一个迭代器。
• 删除指定元素的时候，返回的是这个元素在容器中的个数。(set为0或1，multiset可以大于1)

关于insert:

• 唯一的一个插入元素的动作。
• 插入元素时，返回一个对组。第一个成员是指向新插入值或已存在的这个值的迭代器，第二个成员表示插入成功与否(不存在的，新插入的为真，已存在的不需新插入为假)。
• 范围插入的时候，没有返回值。

查找函数

这才是今天的重点。

iterator find(key);  //查找键key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
size_type count(key); //查找键key的元素个数
iterator lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。
iterator upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。
pair<iterator,iterator> equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。

find函数

find函数，实际上是在红黑树中进行二叉搜索，如果找到了就返回相应位置迭代器，找不到就返回尾后迭代器end().

count函数

根据set不能重复的性质，count非零即一。

lower_bound,upper_bound和equal_range函数

很直接的，lower就是返回第一个大于等于指定元素的迭代器，而upper就是返回第一个大于指定元素的迭代器。如下所示：

int main()
{
    set<int> s;
    s.insert(2);
    s.insert(4);
    s.insert(9);
    s.insert(10);
    s.insert(20);
    auto it1 = s.lower_bound(9);
    auto it2 = s.upper_bound(9);
    cout << "*it1=" << *it1 << " *it2=" << *it2 << endl;
    return 0;
}

我们输出结果为：

*it1=9 *it2=10

由此可以清楚看出这两个函数的作用。

接下来我们介绍equal_range函数。equal_range的作用就是返回查找到的元素的上下限迭代器，同样遵守左闭右开的原则。而这正好是我们lower_bound和upper_bound的返回值。所以，我们可以将equal_range的返回值看做是返回一个存着lower_bound和upper_bound的返回值的对组。

我们可以验证：

int main()
{
    //multiset<int> s;
    set<int> s;
    s.insert(2);
    s.insert(4);
    s.insert(9);
    s.insert(9);
    s.insert(9);
    s.insert(10);
    s.insert(20);
    auto it1 = s.lower_bound(9);
    auto it2 = s.upper_bound(9);
    auto pair = s.equal_range(9);

    if (pair.first == it1 && pair.second == it2)
        cout << "equal_range pair == lower_bound & upper_bound" << endl;
    
    return 0;
}

最后我们成功输出了

"equal_range pair == lower_bound & upper_bound"

set的排序规则

set默认是从小到大排序的，当我们要从大到小排序或者用自定义数据排序的时候，我们就要指定排序规则，同样也是使用仿函数实现：

//functor为仿函数
set<int,functor> s;
...

自己写一个仿函数即可。可参照 我不熟悉的list .

不支持回调函数。

速记：因为set用红黑树实现，插入即排序，排序一旦建立不能更改，所以要在创建set的时候就指定排序规则，而不是插入完了之后再指定。

由于set的特殊性，插入即排序建立。故有此要求。

C++智能指针 shared_ptr

　　shared_ptr 是一个标准的共享所有权的智能指针, 允许多个指针指向同一个对象. 定义在 memory 文件中(非memory.h), 命名空间为 std.

　　shared_ptr 是为了解决 auto_ptr 在对象所有权上的局限性(auto_ptr 是独占的), 在使用引用计数的机制上提供了可以共享所有权的智能指针, 当然这需要额外的开销:
　　(1) shared_ptr 对象除了包括一个所拥有对象的指针外, 还必须包括一个引用计数代理对象的指针.
　　(2) 时间上的开销主要在初始化和拷贝操作上, *和->操作符重载的开销跟auto_ptr是一样.
　　(3) 开销并不是我们不使用shared_ptr的理由, 永远不要进行不成熟的优化, 直到性能分析器告诉你这一点.

　　使用方法:

可以使用模板函数 make_shared 创建对象, make_shared 需指定类型('<>'中)及参数('()'内), 传递的参数必须与指定的类型的构造函数匹配. 如:
　　std::shared_ptr<int> sp1 = std::make_shared<int>(10);
　　std::shared_ptr<std::string> sp2 = std::make_shared<std::string>("Hello c++");
也可以定义 auto 类型的变量来保存 make_shared 的结果.
　　auto sp3 = std::make_shared<int>(11);
　　printf("sp3=%d\n", *sp3);
　　auto sp4 = std::make_shared<std::string>("C++11");
　　printf("sp4=%s\n", (*sp4).c_str());

 

成员函数

use_count 返回引用计数的个数
unique 返回是否是独占所有权( use_count 为 1)
swap 交换两个 shared_ptr 对象(即交换所拥有的对象)
reset 放弃内部对象的所有权或拥有对象的变更, 会引起原有对象的引用计数的减少
get 返回内部对象(指针), 由于已经重载了()方法, 因此和直接使用对象是一样的.如 shared_ptr<int> sp(new int(1)); sp 与 sp.get()是等价的

以下代码演示各个函数的用法与特点:

            std::shared_ptr<int> sp0(new int(2));
            std::shared_ptr<int> sp1(new int(11));
            std::shared_ptr<int> sp2 = sp1;
            printf("%d\n", *sp0);               // 2
            printf("%d\n", *sp1);               // 11
            printf("%d\n", *sp2);               // 11
            sp1.swap(sp0);
            printf("%d\n", *sp0);               // 11
            printf("%d\n", *sp1);               // 2
            printf("%d\n", *sp2);               // 11

            std::shared_ptr<int> sp3(new int(22));
            std::shared_ptr<int> sp4 = sp3;
            printf("%d\n", *sp3);               // 22
            printf("%d\n", *sp4);               // 22
            sp3.reset();                        
            printf("%d\n", sp3.use_count());    // 0
            printf("%d\n", sp4.use_count());    // 1
            printf("%d\n", sp3);                // 0
            printf("%d\n", sp4);                // 指向所拥有对象的地址
            
            std::shared_ptr<int> sp5(new int(22));
            std::shared_ptr<int> sp6 = sp5;
            std::shared_ptr<int> sp7 = sp5;
            printf("%d\n", *sp5);               // 22
            printf("%d\n", *sp6);               // 22
            printf("%d\n", *sp7);               // 22
            printf("%d\n", sp5.use_count());    // 3
            printf("%d\n", sp6.use_count());    // 3
            printf("%d\n", sp7.use_count());    // 3
            sp5.reset(new int(33));                        
            printf("%d\n", sp5.use_count());    // 1
            printf("%d\n", sp6.use_count());    // 2
            printf("%d\n", sp7.use_count());    // 2
            printf("%d\n", *sp5);               // 33
            printf("%d\n", *sp6);               // 22
            printf("%d\n", *sp7);               // 22

shared_ptr 的赋值构造函数和拷贝构造函数:
　　auto r = std::make_shared<int>(); // r 的指向的对象只有一个引用, 其 use_count == 1
　　auto q = r; (或auto q(r);) // 给 r 赋值, 令其指向另一个地址, q 原来指向的对象的引用计数减1(如果为0, 释放内存), r指向的对象的引用计数加1, 此时 q 与 r 指向同一个对象, 并且其引用计数相同, 都为原来的值加1.
以下面的代码测试:

            std::shared_ptr<int> sp1 = std::make_shared<int>(10);
            std::shared_ptr<int> sp2 = std::make_shared<int>(11);
            auto sp3 = sp2; 或 auto sp3(sp2);
            printf("sp1.use_count = %d\n", sp1.use_count());  // 1
            printf("sp2.use_count = %d\n", sp2.use_count());  // 2
            printf("sp3.use_count = %d\n", sp3.use_count());  // 2
            sp3 = sp1;
            printf("sp1.use_count = %d\n", sp1.use_count());  // 2
            printf("sp2.use_count = %d\n", sp2.use_count());  // 1
            printf("sp3.use_count = %d\n", sp3.use_count());  // 2

 

何时需要使用 shared_ptr ?

(1) 程序不知道自己需要使用多少对象. 如使用窗口类, 使用 shared_ptr 为了让多个对象能共享相同的底层数据.

            std::vector<std::string> v1; // 一个空的 vector
            // 在某个新的作用域中拷贝数据到 v1 中
            {
                std::vector<std::string> v2;
                v2.push_back("a");
                v2.push_back("b");
                v2.push_back("c");
                v1 = v2;
            } // 作用域结束时 v2 被销毁, 数据被拷贝到 v1 中

(2) 程序不知道所需对象的准确类型.
(3) 程序需要在多个对象间共享数据.

 

自定义释放器(函数)

　　自定义释放器(函数), 它能完成对 shared_ptr 中保存的指针进行释放操作, 还能处理 shared_ptr 的内部对象未完成的部分工作.

　　假设如下是一个连接管理类, 此类由于历史原因, 无法在析构函数中进行断开连接, 此时用自定义的释放器可以很好的完成此工作:

        class CConnnect
        {
            void Disconnect() { PRINT_FUN(); }
        };

        void Deleter(CConnnect* obj)
        {
            obj->Disconnect(); // 做其它释放或断开连接等工作
            delete obj; // 删除对象指针
        }
        
        std::shared_ptr<CConnnect> sps(new CConnnect, Deleter);

 

使用 shared_ptr 的注意事项

(1) shared_ptr 作为被保护的对象的成员时, 小心因循环引用造成无法释放资源.
　　假设 a 对象中含有一个 shared_ptr<CB> 指向 b 对象, b 对象中含有一个 shared_ptr<CA> 指向 a 对象, 并且 a, b 对象都是堆中分配的。
　　考虑对象 b 中的 m_spa 是我们能最后一个看到 a 对象的共享智能指针, 其 use_count 为2, 因为对象 b 中持有 a 的指针, 所以当 m_spa 说再见时, m_spa 只是把 a 对象的 use_count 改成1; 对象 a 同理; 然后就失去了 a,b 对象的联系.
　　解决此方法是使用 weak_ptr 替换 shared_ptr . 以下为错误用法, 导致相互引用, 最后无法释放对象

            class CB;
            class CA;

            class CA
            {
            public:
                CA(){}
                ~CA(){PRINT_FUN();}

                void Register(const std::shared_ptr<CB>& sp)
                {
                    m_sp = sp;
                }

            private:
                std::shared_ptr<CB> m_sp;
            };

            class CB
            {
            public:
                CB(){};
                ~CB(){PRINT_FUN();};

                void Register(const std::shared_ptr<CA>& sp)
                {
                    m_sp = sp;
                }

            private:
                std::shared_ptr<CA> m_sp;
            };

            std::shared_ptr<CA> spa(new CA);
            std::shared_ptr<CB> spb(new CB);

            spb->Register(spa);
            spa->Register(spb);
            printf("%d\n", spb.use_count()); // 2
            printf("%d\n", spa.use_count()); // 2

　　　　运行上述代码会发现 CA, CB 析构函数都不会打印. 因为他们都没有释放内存.

　　(2) 小心对象内部生成 shared_ptr

            class Y : public std::enable_shared_from_this<Y>
            {
            public:
                std::shared_ptr<Y> GetSharePtr()
                {
                    return shared_from_this();
                }
            };

　　　　对普通的类(没有继承 enable_shared_from_this) T 的 shared_ptr<T> p(new T). p 作为栈对象占8个字节，为了记录( new T )对象的引用计数, p 会在堆上分配 16 个字节以保存引用计数等“智能信息”.
　　　　share_ptr 没有“嵌入(intrusive)”到T对象, 或者说T对象对 share_ptr 毫不知情.
　　　　而 Y 对象则不同, Y 对象已经被“嵌入”了一些 share_ptr 相关的信息, 目的是为了找到“全局性”的那16字节的本对象的“智能信息”.

        考虑下面的代码:
            Y y;
            std::shared_ptr<Y> spy = y.GetSharePtr(); // 错误, y 根本不是 new 创建的
            Y* y = new Y;
            std::shared_ptr<Y> spy = y->GetSharePtr(); // 错误, 问题依旧存在, 程序直接崩溃
        正确用法:
            std::shared_ptr<Y> spy(new Y);
            std::shared_ptr<Y> p = spy->GetSharePtr();
            printf("%d\n", p.use_count()); // 2

　　(3) 小心多线程对引用计数的影响

首先, 如果是轻量级的锁, 比如 InterLockIncrement 等, 对程序影响不大; 如果是重量级的锁, 就要考虑因为 share_ptr 维护引用计数而造成的上下文切换开销.
其次, 多线程同时对 shared_ptr 读写时, 行为不确定, 因为shared_ptr本身有两个成员px，pi. 多线程同时对 px 读写要出问题, 与一个 int 的全局变量多线程读写会出问题的原因一样.

(4) 与 weak_ptr 一起工作时, weak_ptr 在使用前需要检查合法性

        std::weak_ptr<A> wp;
        {
            std::shared_ptr<A>  sp(new A);  //sp.use_count()==1
            wp = sp; //wp不会改变引用计数，所以sp.use_count()==1
            std::shared_ptr<A> sp2 = wp.lock(); //wp没有重载->操作符。只能这样取所指向的对象
        }
        printf("expired:%d\n", wp.expired()); // 1
        std::shared_ptr<A> sp_null = wp.lock(); //sp_null .use_count()==0;

上述代码中 sp 和 sp2 离开了作用域, 其容纳的对象已经被释放了. 得到了一个容纳 NULL 指针的 sp_null 对象.
在使用 wp 前需要调用 wp.expired() 函数判断一下. 因为 wp 还仍旧存在, 虽然引用计数等于0，仍有某处“全局”性的存储块保存着这个计数信息.
直到最后一个 weak_ptr 对象被析构, 这块“堆”存储块才能被回收, 否则 weak_ptr 无法知道自己所容纳的那个指针资源的当前状态.

　　(5) shared_ptr 不支持数组, 如果使用数组, 需要自定义删除器, 如下是一个利用 lambda 实现的删除器:

　　　　　　std::shared_ptr<int> sps(new int[10], [](int *p){delete[] p;});

　　　　对于数组元素的访问, 需使要使用 get 方法取得内部元素的地址后, 再加上偏移量取得.

            for (size_t i = 0; i < 10; i++)
            {
                *((int*)sps.get() + i) = 10 - i;
            }

            for (size_t i = 0; i < 10; i++)
            {
                printf("%d -- %d\n", i, *((int*)sps.get() + i));
            }

 

 

 

VC中的源码实现

template<class _Ty>
class _Ptr_base
{    // base class for shared_ptr and weak_ptr
public:
    typedef _Ptr_base<_Ty> _Myt;
    typedef _Ty _Elem;
    typedef _Elem element_type;

    _Ptr_base()
        : _Ptr(0), _Rep(0)
    {    // construct
    }

    _Ptr_base(_Myt&& _Right)
        : _Ptr(0), _Rep(0)
    {    // construct _Ptr_base object that takes resource from _Right
        _Assign_rv(_STD forward<_Myt>(_Right));
    }

    template<class _Ty2>
    _Ptr_base(_Ptr_base<_Ty2>&& _Right)
        : _Ptr(_Right._Ptr), _Rep(_Right._Rep)
    {    // construct _Ptr_base object that takes resource from _Right
        _Right._Ptr = 0;
        _Right._Rep = 0;
    }

    _Myt& operator=(_Myt&& _Right)
    {    // construct _Ptr_base object that takes resource from _Right
        _Assign_rv(_STD forward<_Myt>(_Right));
        return (*this);
    }

    void _Assign_rv(_Myt&& _Right)
    {    // assign by moving _Right
        if (this != &_Right)
            _Swap(_Right);
    }

    long use_count() const
    {    // return use count
        return (_Rep ? _Rep->_Use_count() : 0);
    }

    void _Swap(_Ptr_base& _Right)
    {    // swap pointers
        _STD swap(_Rep, _Right._Rep);
        _STD swap(_Ptr, _Right._Ptr);
    }

    template<class _Ty2>
    bool owner_before(const _Ptr_base<_Ty2>& _Right) const
    {    // compare addresses of manager objects
        return (_Rep < _Right._Rep);
    }

    void *_Get_deleter(const _XSTD2 type_info& _Type) const
    {    // return pointer to deleter object if its type is _Type
        return (_Rep ? _Rep->_Get_deleter(_Type) : 0);
    }

    _Ty *_Get() const
    {    // return pointer to resource
        return (_Ptr);
    }

    bool _Expired() const
    {    // test if expired
        return (!_Rep || _Rep->_Expired());
    }

    void _Decref()
    {    // decrement reference count
        if (_Rep != 0)
            _Rep->_Decref();
    }

    void _Reset()
    {    // release resource
        _Reset(0, 0);
    }

    template<class _Ty2>
    void _Reset(const _Ptr_base<_Ty2>& _Other)
    {    // release resource and take ownership of _Other._Ptr
        _Reset(_Other._Ptr, _Other._Rep, false);
    }

    template<class _Ty2>
    void _Reset(const _Ptr_base<_Ty2>& _Other, bool _Throw)
    {    // release resource and take ownership from weak_ptr _Other._Ptr
        _Reset(_Other._Ptr, _Other._Rep, _Throw);
    }

    template<class _Ty2>
    void _Reset(const _Ptr_base<_Ty2>& _Other, const _Static_tag&)
    {    // release resource and take ownership of _Other._Ptr
        _Reset(static_cast<_Elem *>(_Other._Ptr), _Other._Rep);
    }

    template<class _Ty2>
    void _Reset(const _Ptr_base<_Ty2>& _Other, const _Const_tag&)
    {    // release resource and take ownership of _Other._Ptr
        _Reset(const_cast<_Elem *>(_Other._Ptr), _Other._Rep);
    }

    template<class _Ty2>
    void _Reset(const _Ptr_base<_Ty2>& _Other, const _Dynamic_tag&)
    {    // release resource and take ownership of _Other._Ptr
        _Elem *_Ptr = dynamic_cast<_Elem *>(_Other._Ptr);
        if (_Ptr)
            _Reset(_Ptr, _Other._Rep);
        else
            _Reset();
    }

    template<class _Ty2>
    void _Reset(auto_ptr<_Ty2>& _Other)
    {    // release resource and take _Other.get()
        _Ty2 *_Px = _Other.get();
        _Reset0(_Px, new _Ref_count<_Elem>(_Px));
        _Other.release();
        _Enable_shared(_Px, _Rep);
    }

#if _HAS_CPP0X
    template<class _Ty2>
    void _Reset(_Ty *_Ptr, const _Ptr_base<_Ty2>& _Other)
    {    // release resource and alias _Ptr with _Other_rep
        _Reset(_Ptr, _Other._Rep);
    }
#endif /* _HAS_CPP0X */

    void _Reset(_Ty *_Other_ptr, _Ref_count_base *_Other_rep)
    {    // release resource and take _Other_ptr through _Other_rep
        if (_Other_rep)
            _Other_rep->_Incref();
        _Reset0(_Other_ptr, _Other_rep);
    }

    void _Reset(_Ty *_Other_ptr, _Ref_count_base *_Other_rep, bool _Throw)
    {    // take _Other_ptr through _Other_rep from weak_ptr if not expired
        // otherwise, leave in default state if !_Throw,
        // otherwise throw exception
        if (_Other_rep && _Other_rep->_Incref_nz())
            _Reset0(_Other_ptr, _Other_rep);
        else if (_Throw)
            _THROW_NCEE(bad_weak_ptr, 0);
    }

    void _Reset0(_Ty *_Other_ptr, _Ref_count_base *_Other_rep)
    {    // release resource and take new resource
        if (_Rep != 0)
            _Rep->_Decref();
        _Rep = _Other_rep;
        _Ptr = _Other_ptr;
    }

    void _Decwref()
    {    // decrement weak reference count
        if (_Rep != 0)
            _Rep->_Decwref();
    }

    void _Resetw()
    {    // release weak reference to resource
        _Resetw((_Elem *)0, 0);
    }

    template<class _Ty2>
    void _Resetw(const _Ptr_base<_Ty2>& _Other)
    {    // release weak reference to resource and take _Other._Ptr
        _Resetw(_Other._Ptr, _Other._Rep);
    }

    template<class _Ty2>
    void _Resetw(const _Ty2 *_Other_ptr, _Ref_count_base *_Other_rep)
    {    // point to _Other_ptr through _Other_rep
        _Resetw(const_cast<_Ty2*>(_Other_ptr), _Other_rep);
    }

    template<class _Ty2>
    void _Resetw(_Ty2 *_Other_ptr, _Ref_count_base *_Other_rep)
    {    // point to _Other_ptr through _Other_rep
        if (_Other_rep)
            _Other_rep->_Incwref();
        if (_Rep != 0)
            _Rep->_Decwref();
        _Rep = _Other_rep;
        _Ptr = _Other_ptr;
    }

private:
    _Ty *_Ptr;
    _Ref_count_base *_Rep;
    template<class _Ty0>
    friend class _Ptr_base;
};



template<class _Ty>
class shared_ptr
    : public _Ptr_base<_Ty>
{    // class for reference counted resource management
public:
    typedef shared_ptr<_Ty> _Myt;
    typedef _Ptr_base<_Ty> _Mybase;

    shared_ptr()
    {    // construct empty shared_ptr object
    }

    template<class _Ux>
    explicit shared_ptr(_Ux *_Px)
    {    // construct shared_ptr object that owns _Px
        _Resetp(_Px);
    }

    template<class _Ux,
    class _Dx>
        shared_ptr(_Ux *_Px, _Dx _Dt)
    {    // construct with _Px, deleter
        _Resetp(_Px, _Dt);
    }

    //#if _HAS_CPP0X

#if defined(_NATIVE_NULLPTR_SUPPORTED) \
    && !defined(_DO_NOT_USE_NULLPTR_IN_STL)

    shared_ptr(_STD nullptr_t)
    {    // construct with nullptr
        _Resetp((_Ty *)0);
    }

    template<class _Dx>
    shared_ptr(_STD nullptr_t, _Dx _Dt)
    {    // construct with nullptr, deleter
        _Resetp((_Ty *)0, _Dt);
    }

    template<class _Dx,
    class _Alloc>
        shared_ptr(_STD nullptr_t, _Dx _Dt, _Alloc _Ax)
    {    // construct with nullptr, deleter, allocator
        _Resetp((_Ty *)0, _Dt, _Ax);
    }
#endif /* defined(_NATIVE_NULLPTR_SUPPORTED) etc. */

    template<class _Ux,
    class _Dx,
    class _Alloc>
        shared_ptr(_Ux *_Px, _Dx _Dt, _Alloc _Ax)
    {    // construct with _Px, deleter, allocator
        _Resetp(_Px, _Dt, _Ax);
    }
    //#endif /* _HAS_CPP0X */

#if _HAS_CPP0X
    template<class _Ty2>
    shared_ptr(const shared_ptr<_Ty2>& _Right, _Ty *_Px)
    {    // construct shared_ptr object that aliases _Right
        this->_Reset(_Px, _Right);
    }
#endif /* _HAS_CPP0X */

    shared_ptr(const _Myt& _Other)
    {    // construct shared_ptr object that owns same resource as _Other
        this->_Reset(_Other);
    }

    template<class _Ty2>
    shared_ptr(const shared_ptr<_Ty2>& _Other,
        typename enable_if<is_convertible<_Ty2 *, _Ty *>::value,
        void *>::type * = 0)
    {    // construct shared_ptr object that owns same resource as _Other
        this->_Reset(_Other);
    }

    template<class _Ty2>
    explicit shared_ptr(const weak_ptr<_Ty2>& _Other,
        bool _Throw = true)
    {    // construct shared_ptr object that owns resource *_Other
        this->_Reset(_Other, _Throw);
    }

    template<class _Ty2>
    shared_ptr(auto_ptr<_Ty2>& _Other)
    {    // construct shared_ptr object that owns *_Other.get()
        this->_Reset(_Other);
    }

    template<class _Ty2>
    shared_ptr(const shared_ptr<_Ty2>& _Other, const _Static_tag& _Tag)
    {    // construct shared_ptr object for static_pointer_cast
        this->_Reset(_Other, _Tag);
    }

    template<class _Ty2>
    shared_ptr(const shared_ptr<_Ty2>& _Other, const _Const_tag& _Tag)
    {    // construct shared_ptr object for const_pointer_cast
        this->_Reset(_Other, _Tag);
    }

    template<class _Ty2>
    shared_ptr(const shared_ptr<_Ty2>& _Other, const _Dynamic_tag& _Tag)
    {    // construct shared_ptr object for dynamic_pointer_cast
        this->_Reset(_Other, _Tag);
    }

    shared_ptr(_Myt&& _Right)
        : _Mybase(_STD forward<_Myt>(_Right))
    {    // construct shared_ptr object that takes resource from _Right
    }

    template<class _Ty2>
    shared_ptr(shared_ptr<_Ty2>&& _Right,
        typename enable_if<is_convertible<_Ty2 *, _Ty *>::value,
        void *>::type * = 0)
        : _Mybase(_STD forward<shared_ptr<_Ty2> >(_Right))
    {    // construct shared_ptr object that takes resource from _Right
    }

#if _HAS_CPP0X
    template<class _Ux,
    class _Dx>
        shared_ptr(_STD unique_ptr<_Ux, _Dx>&& _Right)
    {    // construct from unique_ptr
        _Resetp(_Right.release(), _Right.get_deleter());
    }

    template<class _Ux,
    class _Dx>
        _Myt& operator=(unique_ptr<_Ux, _Dx>&& _Right)
    {    // move from unique_ptr
        shared_ptr(_STD move(_Right)).swap(*this);
        return (*this);
    }
#endif /* _HAS_CPP0X */

    _Myt& operator=(_Myt&& _Right)
    {    // construct shared_ptr object that takes resource from _Right
        shared_ptr(_STD move(_Right)).swap(*this);
        return (*this);
    }

    template<class _Ty2>
    _Myt& operator=(shared_ptr<_Ty2>&& _Right)
    {    // construct shared_ptr object that takes resource from _Right
        shared_ptr(_STD move(_Right)).swap(*this);
        return (*this);
    }

    void swap(_Myt&& _Right)
    {    // exchange contents with movable _Right
        _Mybase::swap(_STD move(_Right));
    }

    ~shared_ptr()
    {    // release resource
        this->_Decref();
    }

    _Myt& operator=(const _Myt& _Right)
    {    // assign shared ownership of resource owned by _Right
        shared_ptr(_Right).swap(*this);
        return (*this);
    }

    template<class _Ty2>
    _Myt& operator=(const shared_ptr<_Ty2>& _Right)
    {    // assign shared ownership of resource owned by _Right
        shared_ptr(_Right).swap(*this);
        return (*this);
    }

    template<class _Ty2>
    _Myt& operator=(auto_ptr<_Ty2>& _Right)
    {    // assign ownership of resource pointed to by _Right
        shared_ptr(_Right).swap(*this);
        return (*this);
    }

    void reset()
    {    // release resource and convert to empty shared_ptr object
        shared_ptr().swap(*this);
    }

    template<class _Ux>
    void reset(_Ux *_Px)
    {    // release, take ownership of _Px
        shared_ptr(_Px).swap(*this);
    }

    template<class _Ux,
    class _Dx>
        void reset(_Ux *_Px, _Dx _Dt)
    {    // release, take ownership of _Px, with deleter _Dt
        shared_ptr(_Px, _Dt).swap(*this);
    }

    //#if _HAS_CPP0X
    template<class _Ux,
    class _Dx,
    class _Alloc>
        void reset(_Ux *_Px, _Dx _Dt, _Alloc _Ax)
    {    // release, take ownership of _Px, with deleter _Dt, allocator _Ax
        shared_ptr(_Px, _Dt, _Ax).swap(*this);
    }
    //#endif /* _HAS_CPP0X */

    void swap(_Myt& _Other)
    {    // swap pointers
        this->_Swap(_Other);
    }

    _Ty *get() const
    {    // return pointer to resource
        return (this->_Get());
    }

    typename tr1::add_reference<_Ty>::type operator*() const
    {    // return reference to resource
        return (*this->_Get());
    }

    _Ty *operator->() const
    {    // return pointer to resource
        return (this->_Get());
    }

    bool unique() const
    {    // return true if no other shared_ptr object owns this resource
        return (this->use_count() == 1);
    }

    _OPERATOR_BOOL() const
    {    // test if shared_ptr object owns no resource
        return (this->_Get() != 0 ? _CONVERTIBLE_TO_TRUE : 0);
    }

private:
    template<class _Ux>
    void _Resetp(_Ux *_Px)
    {    // release, take ownership of _Px
        _TRY_BEGIN    // allocate control block and reset
            _Resetp0(_Px, new _Ref_count<_Ux>(_Px));
        _CATCH_ALL    // allocation failed, delete resource
            delete _Px;
        _RERAISE;
        _CATCH_END
    }

    template<class _Ux,
    class _Dx>
        void _Resetp(_Ux *_Px, _Dx _Dt)
    {    // release, take ownership of _Px, deleter _Dt
        _TRY_BEGIN    // allocate control block and reset
            _Resetp0(_Px, new _Ref_count_del<_Ux, _Dx>(_Px, _Dt));
        _CATCH_ALL    // allocation failed, delete resource
            _Dt(_Px);
        _RERAISE;
        _CATCH_END
    }

    //#if _HAS_CPP0X
    template<class _Ux,
    class _Dx,
    class _Alloc>
        void _Resetp(_Ux *_Px, _Dx _Dt, _Alloc _Ax)
    {    // release, take ownership of _Px, deleter _Dt, allocator _Ax
        typedef _Ref_count_del_alloc<_Ux, _Dx, _Alloc> _Refd;
        typename _Alloc::template rebind<_Refd>::other _Al = _Ax;

        _TRY_BEGIN    // allocate control block and reset
            _Refd *_Ptr = _Al.allocate(1);
        new (_Ptr) _Refd(_Px, _Dt, _Al);
        _Resetp0(_Px, _Ptr);
        _CATCH_ALL    // allocation failed, delete resource
            _Dt(_Px);
        _RERAISE;
        _CATCH_END
    }
    //#endif /* _HAS_CPP0X */

public:
    template<class _Ux>
    void _Resetp0(_Ux *_Px, _Ref_count_base *_Rx)
    {    // release resource and take ownership of _Px
        this->_Reset0(_Px, _Rx);
        _Enable_shared(_Px, _Rx);
    }
};