1
struct myobj{
2
    myobj(int x):val(x){}
3
    int val;
4
};
5

6
void deleter(myobj* ptr){
7
    cout <<"deleter called" << endl;
8
    delete ptr;        //需要在这里删掉new出来的内容 如果不写的话会内存泄漏。因为智能指针不再执行自己的释放资源的函数。改为执行这个函数。但是这个函数里面如果没有释放资源就会内存泄漏。
9
    ptr = nullptr;
10
}
11

12

13
template<typename T>
14
class mydeleter{     //自定义删除器类。functor
15
    public:
16
        void operator()(T* ptr) const{
17
            cout <<"deleter called" << endl;
18
            delete ptr;
19
            ptr = nullptr;
20
        }
21
};
22

23
int main(){
24
    unique_ptr<myobj> ptr1;                                         //空指针
25
    unique_ptr<myobj> ptr2 = new myobj(5);                          //错误。智能指针构造函数是explicit的。禁止隐式转换，所以不允许带有隐式转换的拷贝初始化。但是可以用直接初始化
26
    unique_ptr<myobj> ptr3(new myobj(5));                           //ok
27
    unique_ptr<myobj> ptr3_1 = move(ptr3);             //使用move拷贝初始化
28
    unique_ptr<myobj> ptr3_2(move(ptr3));            //使用move直接初始化
29
    unique_ptr<myobj, void(*)(myobj*)> ptr4(new myobj(5), deleter); //自定义删除器。注意需要在自定义删除器内部进行资源释放，因为使用自定义删除器后，智能指针不会接管释放资源。注意这里传入的是函数指针，会使unique_ptr整体增大，变成两个指针。正确使用应该是下面那种定义类型。
30
    unique_ptr<myobj, mydeleter<myobj>> ptr4_1(new myobj(5));       //自定义删除器。注意，这里在尖括号内传入的是仿函数类型。这样会直接使用类型的可调用对象做为删除器。这样效率很高，少一个指针
31
    //所以写自定义删除器的意义是如果你想在某一个资源的析构函数或者是释放资源的同时执行其他动作，就需要写这个。因为，资源的释放阶段是全部交给智能指针接管的。
32
    unique_ptr<myobj> ptr5 = make_unique<myobj>(new myobj(5));      //错误 使用make方法。make_unique是把传入参数完美转发至对象构造函数。只需要传递参数即可，无需再次new。
33
    unique_ptr<myobj> ptr5 = make_unique<myobj>(5);                 //使用make方法。make方法无法使用自定义删除器和大括号初始化（列表初始化）
34
    unique_ptr<myobj> ptr5_1(make_unique<myobj>(5));         //使用make方法。直接初始化
35
    unique_ptr<myobj> ptr5(ptr3);                                   //禁止拷贝。因为只能有一个unique_ptr指向一个资源。所有权语义。
36
    ptr5 = ptr3;                          //禁止拷贝赋值。
37

38
    //------------------------------------------------------------------------
39
    unique_ptr<int>a_ptr(new int(20)); //使用直接初始化
40
    a_ptr = make_unique<int>(30); //依旧可以。这里调用的是operator=，参数是unique_ptr<int>&&。因为make_unique会按值返回一个unique_ptr对象，所以是右值。并且unique_ptr& operator=( unique_ptr&& r )会先把自己的资源释放掉，再接管新的资源，此处不会有内存泄漏。
41
}

1
Base(std::unique_ptr<Base> &&n): next(std::move(n)) {}

1
Base newBase(std::unique_ptr<Base>(new Base));

1
Base newBase(std::move(nextBase));

1
void funca(unique_ptr<int>&& ptr){ //注意我们的形参不是值传递，而是右值引用。所以我们没有拷贝，也没有赋值。什么都没做。引用传递不构造新对象对吧？右值引用也是引用呀。所以funca什么都没做。
2
    cout <<"called " << endl;
3
}
4
int main(){
5
    unique_ptr<int> ptr1(new int (10));
6
    funca(move(ptr1)); //记住，这里move仅仅是static_cast成了一个右值引用的形式。这时候允许传入funca。具体是否要调用移动构造需要看funca是值传递还是引用传递。
7
    if(ptr1.get() != nullptr){
8
        cout <<"not null" << endl;
9
    }
10
    cout << *ptr1 << endl;
11
    return 0;
12
}
13
/*
14
输出：
15
called
16
not null
17
10
18
*/

1
class v{
2
    public:
3
        unique_ptr<int> ptr;
4
        v(unique_ptr<int>&& rhs): ptr(move(rhs)){} //注意这里，我们产生了构造动作。调用了移动构造。
5
};
6
void funca(unique_ptr<int>&& ptr){
7
    cout <<"called " << endl;
8
}
9
int main(){
10
    unique_ptr<int> ptr1(new int (10));
11
    v obj(move(ptr1));
12
    if(ptr1.get() != nullptr){
13
        cout <<"not null" << endl;
14
    }
15
    else{
16
        cout << "null" << endl;
17
    }
18

19
    return 0;
20
}
21
/*
22
输出
23
null
24
*/

1
shared_ptr<myobj> ptr1(new myobj(5));       //创建共享指针
2
shared_ptr<myobj> ptr2(ptr1);               //通过共享指针直接初始化共享指针。两个指针指向同一个数据，所以不新建控制块。引用计数+1
3
shared_ptr<myobj> ptr3 = ptr1;              //可以通过赋值方法拷贝初始化共享指针。两个指针指向同一个数据，所以不新建控制块。引用计数+1
4
cout << ptr1.use_count() << endl;           //使用use_count查看引用计数。输出3
5
cout << ptr2.use_count() << endl;           //输出3
6
cout << ptr3.use_count() << endl;           //输出3
7

8
shared_ptr<myobj> ptr4 = make_shared<myobj>(5);     //使用make方法创建
9
shared_ptr<myobj> ptr4_1(make_shared<myobj>(5));    //使用make方法直接初始化
10
ptr4 = ptr3;                                        //可以拷贝赋值。此时ptr4的控制块引用计数为0。因为被3覆盖了。所以ptr4指向的原始资源析构。ptr4此时和ptr3指向同一资源
11
cout << ptr4.use_count()<<endl;                     //共享控制块，此时为4。
12

13
shared_ptr<myobj> ptr5 = new myobj(4);              //不可以。禁止隐式转换。智能指针构造函数是explicit的。所以不允许使用带有隐式转换的拷贝初始化。但可以使用直接初始化
14
shared_ptr<myobj> ptr5_1(new myobj(4));          //可以 裸指针直接初始化
15
shared_ptr<myobj> ptr6(new myobj(4), deleter);      //自定义删除器。无需指定类型名。

1
void fn(shared_ptr<A>& sp) {
2
    ...
3
    if (..) {
4
        sp = other_sp;
5
    } else if (...) {
6
        sp = other_sp2;
7
    }
8
}

1
shared_ptr<int> func1(){
2
    return make_shared<int>(10);
3
}
4

5

6
int main(){
7

8
    shared_ptr<int> ptr = func1();
9
    cout << ptr.use_count() << endl; //返回1
10
    return 0;
11

12
}

1
class st:public enable_shared_from_this<st>{
2
    public:
3
    int val = 100;
4
    shared_ptr<st> getptr(){
5
        return shared_from_this();
6
    }
7
};
8

9

10
int main(){
11
  st obj;//错误
12
    shared_ptr<st> obj(new st);//正确
13
    shared_ptr<st> t = obj->getptr(); //别搞混了。访问储存的对象的成员函数用->
14
    cout << t->val << endl;
15
    cout << obj.use_count()<<endl;//访问shared_ptr本身的成员函数用.
16
    cout << t.use_count()<<endl;
17
}

1
weak_ptr<myobj> ptr2(ptr1);                 //可以 直接初始化
2
weak_ptr<myobj> ptr3 = ptr1;                //可以 隐式隐式转换后使用拷贝初始化。
3
weak_ptr<myobj> ptr4(ptr1);                 //可以 弱指针初始化弱指针
4
ptr4 = ptr2;                                //可以 拷贝赋值
5
weak_ptr<myobj> ptr5(new myobj(7));         //不可以使用裸指针初始化弱指针。
6

7
unique_ptr<myobj> ptr7(new myobj(5));
8
weak_ptr<myobj> test1(ptr7);                //不可以使用unique指针初始化弱指针

1
shared_ptr<int> sptr(wkptr);

1
std::shared_ptr<Widget> spw(new Widget, cusDel);
2
processWidget(spw, computePriority());

1
std::shared_ptr<Widget> spw(new Widget, cusDel);
2
processWidget(std::move(spw), computePriority());

1
template <class T, class D = default_delete<T>>
2
class unique_ptr {
3
public:
4
    ...
5
    unique_ptr (pointer p,
6
        typename conditional<is_reference<D>::value,D,const D&> del) noexcept;
7
    ...
8
};
9

10
template <class T>
11
class shared_ptr {
12
public:
13
    ...
14
    template <class U, class D>
15
    shared_ptr (U* p, D del); //删除器只是构造函数参数的一部分，而不是shared_ptr类型的一部分
16
    ...
17
};

1
struct myobj{
2
    myobj(int x):val(x){}
3
    int val;
4
};
5

6

7
int main(){
8

9
    unique_ptr<myobj> unique = make_unique<myobj>(5);
10
    auto lambda = [=](int a){ unique->val = unique->val + a;}; //报错，因为unique_ptr不允许拷贝。
11
    auto lambda = [&](int a){ unique->val = unique->val + a;};
12
    lambda(10);
13
    cout << unique->val<< endl; //输出15
14

15
    return 0;
16
}

1
struct myobj{
2
    myobj(int x):val(x){}
3
    int val;
4
};
5

6

7
int main(){
8

9
    unique_ptr<myobj> unique = make_unique<myobj>(5);
10
    auto lambda = [&, temp_unique = move(unique)](int a) mutable{  //注释1
11
        temp_unique->val = temp_unique->val + a;
12
        unique = move(temp_unique); //注释2
13
        };
14
    lambda(10);
15
    cout << unique->val<< endl;
16
    return 0;
17
}
18
//上面这个例子并不太好。因为我们做的事情是：引用捕获unique，然后把unique移动到一个新建的lambda内局部变量temp上。
19
//然后对temp进行处理，然后再移动到unique上。这也是为什么必须有一个&来引用捕获unique。这完全脱裤子放屁
20
//所以正常这种情况下的使用方式应该是移动进lambda后，外部不会再使用该智能指针
21
int main(){
22

23
    unique_ptr<myobj> unique = make_unique<myobj>(5);
24
    auto lambda = [temp_unique = move(unique)](int a) mutable{  //移动进来
25
        temp_unique->val = temp_unique->val + a;
26
        cout << temp_unique->val << endl; //对数据处理。
27
        };
28
    lambda(10);
29
    //外部并不会再次使用unique指针。
30
    return 0;
31
}

1
shared_ptr<myobj> shared = make_shared<myobj>(5);
2
shared_ptr<myobj> shared2 = shared;
3
cout << shared2.use_count() << endl; //输出2
4
shared_ptr<myobj>& sharedref = shared; //创建引用
5
cout << shared2.use_count() << endl; //依旧输出2

1
int main(){
2
    shared_ptr<myobj> shared = make_shared<myobj>(5);
3
    auto lambda = [&](int b){ //错误地按照引用捕获
4
        cout << shared->val + b << endl;
5

6
    };
7
    shared.reset(); //计数器-1，如果为0就释放。此时已经释放了
8
    lambda(10); //崩溃
9
    return 0;
10
}

1
int main(){
2
    shared_ptr<myobj> shared = make_shared<myobj>(5);
3
    auto lambda = [=](int b){
4
        cout << shared->val + b << endl;
5
        cout <<"in lambda:" <<shared.use_count() << endl; //输出1
6
    };
7
    cout <<"out lambda:" <<shared.use_count() << endl; // 输出2
8
    shared.reset(); //reset的是全局作用域的shared。
9
    cout <<"out lambda:" <<shared.use_count() << endl; //输出0 不要惊讶
10
    lambda(10);
11
    return 0;
12
}

1
class innerobj{
2
    public:
3
        int inner_val;
4
        innerobj(int x):inner_val(x){}
5
};
6

7
class myobj {
8
public:
9
  myobj(int n):obj(n){}
10
  ~myobj() {
11
    cout << "myobj的析构 "<< obj.inner_val << endl;
12
  }
13
  innerobj obj;
14

15
};
16
int main() {
17
    shared_ptr<myobj> ptr{ new myobj(5) };//ptr是共享对象（也就是new出来的myobj）的唯一拥有者
18
    shared_ptr<innerobj> sub_ptr(ptr, &(ptr->obj)); //此时sub_ptr的控制块和ptr共享，但是subptr的存储指针直接指向myobj的innerobj成员变量。
19
    //记得要取地址。第二个参数要传入指针。
20

21
    cout << ptr.use_count() << endl; //2 引用计数被+1
22
    cout << sub_ptr.use_count() << endl; //2 引用计数被+1
23

24
    ptr.reset(); //reset, 此时ptr为空。
25
    cout << ptr.use_count() << endl; //0 无控制块
26
    cout << sub_ptr.use_count() << endl; //1 引用计数被-1
27

28
    cout << sub_ptr->inner_val << endl; //正常输出5 。
29

30

31
    return 0;
32
}