1
operator T*() const{
2
    //return static_cast<T*>(this->object); 这行是VTK源码但不知道为何要这么做。
3
    return this->object;
4
}

1
struct b{
2

3
};
4

5
struct d:b{
6

7
};
8

9
void func(area2::unique_ptr<b> ptr){
10
    cout <<"called" << endl;
11
}
12
void formalfunc(unique_ptr<b> ptr){
13
    cout <<"formal" << endl;
14
}
15
int main(){
16
    area2::unique_ptr<b> ptr(new b());
17
    func(move(ptr)); //可以。因为此时类型是b
18
    area2::unique_ptr<b> ptr2(new d());
19
    func(move(ptr2)); //可以。因为此时类型是b
20

21
    area2::unique_ptr<d> ptr2(new d());
22
    func(move(ptr2)); //不可以。因为此时类型是d
23

24
    unique_ptr<d> uptr(new d()); //针对标准库的智能指针，这样可以，因为有隐式类型转换。
25
    formalfunc(move(uptr)); //可以。有隐式类型转换。
26
}

1
template<typename _Tp>
2
    struct default_delete
3
    {
4
      /// Default constructor
5
      constexpr default_delete() noexcept = default; //默认删除器的默认构造
6

7
      /** @brief Converting constructor.
8
       *
9
       * Allows conversion from a deleter for objects of another type, `_Up`,
10
       * only if `_Up*` is convertible to `_Tp*`.
11
       */
12
      template<typename _Up,
13
         typename = _Require<is_convertible<_Up*, _Tp*>>>
14
  _GLIBCXX23_CONSTEXPR
15
        default_delete(const default_delete<_Up>&) noexcept { } //一个构造函数模板用来在查看默认删除器是否可以被类型转换后进行类型转换。这里很重要
16

17
      /// Calls `delete __ptr`
18
      _GLIBCXX23_CONSTEXPR
19
      void
20
      operator()(_Tp* __ptr) const
21
      {
22
  static_assert(!is_void<_Tp>::value,
23
          "can't delete pointer to incomplete type");
24
  static_assert(sizeof(_Tp)>0,
25
          "can't delete pointer to incomplete type");
26
  delete __ptr;
27
      }
28
    };
29

30
//unique_ptr的构造函数6
31
template<typename _Up, typename _Ep, typename = _Require<
32
               __safe_conversion_up<_Up, _Ep>,
33
         __conditional_t<is_reference<_Dp>::value,
34
             is_same<_Ep, _Dp>,
35
             is_convertible<_Ep, _Dp>>>>
36
  _GLIBCXX23_CONSTEXPR
37
  unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
38
  : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) //非常单纯的赋值
39
  { }

1
template<typename T>
2
void pivot(T p){
3
    std::puts(__PRETTY_FUNCTION__); //查看函数签名
4
}
5
class myobj{
6
    public:
7
    int* ptrs;
8
    myobj(int val):ptrs(new int(val)){}
9
    ~myobj(){
10
        if(ptrs != nullptr){
11
            delete ptrs;
12
            ptrs = nullptr;
13
        }
14
    }
15
};
16

17
namespace area2{
18
    template<typename T>
19
    class default_deleter{ //默认形式的删除器
20
        public:
21
        default_deleter() = default;
22
        //模拟默认删除器的构造函数模板
23
        template<typename _Up, typename = typename enable_if<is_convertible<_Up*, T*>::value>::type> //注意必须是指针类型的可转换性
24
        default_deleter(const default_deleter<_Up>&){
25
            std::puts(__PRETTY_FUNCTION__); //2
26
        }
27
        default_deleter& operator=(const default_deleter& rhs){
28
            cout <<"operator= called" << endl; //4
29
            return *this;
30
        }
31
        void operator()(T *p) const {
32
            std::puts(__PRETTY_FUNCTION__); //6
33
            if(p != nullptr){
34
                delete p;
35
                p = nullptr;
36
            }
37
        }
38
    };
39

40
    template<typename T, typename Deleter = default_deleter<T>> //模板表示接受T类型一个接受T类型的删除器
41
    class unique_ptr{
42
        public:
43
        T* p_ = nullptr; //T类型指针
44
        Deleter d_; //删除器
45
    //.....
46
        //模拟构造函数6
47
        template<typename U, typename E>
48
        unique_ptr(unique_ptr<U,E>&& u){
49
            this->p_ = u.p_; //指针赋值。自然转换
50
            //----------------
51
            pivot(u.d_); //1
52
            default_deleter<T> temp(u.d_);
53
            pivot(temp); //3
54
            this->d_ = temp;
55
            //----上面的区域可以换成下面一行------------
56
            //this->d = u.d_
57
            u.p_ = nullptr;
58
        }
59
    //......
60
}

1
void pivot(T) [with T = area2::default_deleter<d>] //1
2
area2::default_deleter<T>::default_deleter(const area2::default_deleter<_Up>&) [with _Up = d; <template-parameter-2-2> = void; T = b] //2
3
void pivot(T) [with T = area2::default_deleter<b>] //3
4
operator= called //4
5
called
6
void area2::default_deleter<T>::operator()(T*) const [with T = b] //6

1
area2::unique_ptr<d> ptr3(new d());
2
area2::unique_ptr<b> ptr(move(ptr3));

1
template<typename _Up, typename = typename enable_if<is_convertible<_Up*, T*>::value>::type>
2
    default_deleter(const default_deleter<_Up>&){
3
    std::puts(__PRETTY_FUNCTION__); //2
4
}

1
struct b{
2

3
};
4

5
struct d:b{
6

7
};
8

9
void func(area2::unique_ptr<b> ptr){
10
    cout <<"called" << endl;
11
}
12

13
int main(){
14
    area2::unique_ptr<d> ptr3(new d()); //现在不会报错了
15
    func(move(ptr3));
16

17
}