1. c++中使用std::shared_ptr类型做为构造函数参数，并使用std::move()初始化成员变量。

使用std::shared_ptr类型作为形参，shared_ptr会被复制，使用std::move()之后，形参对象就没有内容了。

#include <iostream>
#include <utility>
#include <memory>

class Base
{
public:
    Base(std::shared_ptr<int> a, std::shared_ptr<int> b)
        : x{ std::move(a) }
        , y{ std::move(b) }
    {
        std::cout << "a->count=" << a.use_count() << std::endl;
        std::cout << "b->count=" << b.use_count() << std::endl;
    }

    void display()
    {
        std::cout << "member: x->count=" << x.use_count() << std::endl;
        std::cout << "member: y->count=" << y.use_count() << std::endl;
        std::cout << "--------------------------------" << std::endl;
    }
private:
    std::shared_ptr<int> x;
    std::shared_ptr<int> y;
};

int main(void)
{
    auto sp1 = std::make_shared<int>(111);
    std::cout << "sp1->count=" << sp1.use_count() << std::endl;
    decltype(sp1) sp2 = sp1;
    std::cout << "sp1->count=" << sp1.use_count() << std::endl;
    std::cout << "sp2->count=" << sp2.use_count() << std::endl;
    auto sp4 = std::make_shared<int>(444);
    std::cout << "sp4->count=" << sp4.use_count() << std::endl;
    Base b(sp1, sp4);
    b.display();
    std::cout << "sp1->count=" << sp1.use_count() << std::endl;
    std::cout << "sp2->count=" << sp2.use_count() << std::endl;
    std::cout << "sp4->count=" << sp4.use_count() << std::endl;

    return 0;
}

结果如下：

2. c++中使用std::shared_ptr类型做为构造函数参数，并直接初始化成员变量。

使用std::shared_ptr类型作为形参，shared_ptr会被复制，使用初始化复制之后，又相当于复制了一份shared_ptr。

#include <iostream>
#include <utility>
#include <memory>

class Base
{
public:
    Base(std::shared_ptr<int> a, std::shared_ptr<int> b)
        : x{ a }
        , y{ b }
    {
        std::cout << "a->count=" << a.use_count() << std::endl;
        std::cout << "b->count=" << b.use_count() << std::endl;
    }

    void display()
    {
        std::cout << "member: x->count=" << x.use_count() << std::endl;
        std::cout << "member: y->count=" << y.use_count() << std::endl;
        std::cout << "--------------------------------" << std::endl;
    }
private:
    std::shared_ptr<int> x;
    std::shared_ptr<int> y;
};

int main(void)
{
    auto sp1 = std::make_shared<int>(111);
    std::cout << "sp1->count=" << sp1.use_count() << std::endl;
    decltype(sp1) sp2 = sp1;
    std::cout << "sp1->count=" << sp1.use_count() << std::endl;
    std::cout << "sp2->count=" << sp2.use_count() << std::endl;
    auto sp4 = std::make_shared<int>(444);
    std::cout << "sp4->count=" << sp4.use_count() << std::endl;
    Base b(sp1, sp4);
    b.display();
    std::cout << "sp1->count=" << sp1.use_count() << std::endl;
    std::cout << "sp2->count=" << sp2.use_count() << std::endl;
    std::cout << "sp4->count=" << sp4.use_count() << std::endl;

    return 0;
}

 结果如下：

3. c++中使用std::shared_ptr通过引用的方式做为构造函数参数，并使用std::move()初始化成员变量。

使用std::shared_ptr类型引用作为形参，shared_ptr就不会被复制，使用std::move()之后，形参对象就没有内容了。

#include <iostream>
#include <utility>
#include <memory>

class Base
{
public:
      Base(std::shared_ptr<int>& a, std::shared_ptr<int>& b)
          : x{ std::move(a) }
          , y{ std::move(b) }
    {
        std::cout << "a->count=" << a.use_count() << std::endl;
        std::cout << "b->count=" << b.use_count() << std::endl;
    }

    void display()
    {
        std::cout << "member: x->count=" << x.use_count() << std::endl;
        std::cout << "member: y->count=" << y.use_count() << std::endl;
        std::cout << "--------------------------------" << std::endl;
    }
private:
    std::shared_ptr<int> x;
    std::shared_ptr<int> y;
};

int main(void)
{
    auto sp1 = std::make_shared<int>(111);
    std::cout << "sp1->count=" << sp1.use_count() << std::endl;
    decltype(sp1) sp2 = sp1;
    std::cout << "sp1->count=" << sp1.use_count() << std::endl;
    std::cout << "sp2->count=" << sp2.use_count() << std::endl;
    auto sp4 = std::make_shared<int>(444);
    std::cout << "sp4->count=" << sp4.use_count() << std::endl;
    Base b(sp1, sp4);
    b.display();
    std::cout << "sp1->count=" << sp1.use_count() << std::endl;
    std::cout << "sp2->count=" << sp2.use_count() << std::endl;
    std::cout << "sp4->count=" << sp4.use_count() << std::endl;

    return 0;
}

结果如下：

4. c++中使用std::shared_ptr通过引用的方式做为构造函数参数，并直接初始化成员变量。

使用std::shared_ptr类型引用作为形参，shared_ptr就不会被复制，使用初始化复制之后，又相当于复制了一份shared_ptr。

#include <iostream>
#include <utility>
#include <memory>

class Base
{
public:
    Base(std::shared_ptr<int>& a, std::shared_ptr<int>& b)
        : x{ a }
        , y{ b }
    {
        std::cout << "a->count=" << a.use_count() << std::endl;
        std::cout << "b->count=" << b.use_count() << std::endl;
    }

    void display()
    {
        std::cout << "member: x->count=" << x.use_count() << std::endl;
        std::cout << "member: y->count=" << y.use_count() << std::endl;
        std::cout << "--------------------------------" << std::endl;
    }
private:
    std::shared_ptr<int> x;
    std::shared_ptr<int> y;
};

int main(void)
{
    auto sp1 = std::make_shared<int>(111);
    std::cout << "sp1->count=" << sp1.use_count() << std::endl;
    decltype(sp1) sp2 = sp1;
    std::cout << "sp1->count=" << sp1.use_count() << std::endl;
    std::cout << "sp2->count=" << sp2.use_count() << std::endl;
    auto sp4 = std::make_shared<int>(444);
    std::cout << "sp4->count=" << sp4.use_count() << std::endl;
    Base b(sp1, sp4);
    b.display();
    std::cout << "sp1->count=" << sp1.use_count() << std::endl;
    std::cout << "sp2->count=" << sp2.use_count() << std::endl;
    std::cout << "sp4->count=" << sp4.use_count() << std::endl;

    return 0;
}

结果如下：