c++ 计数指针shared_ptr

 shared_ptr定义

 shared_ptr 是C++11提供的一种智能指针类，又被称为共享指针，它足够智能，可以在任何地方都不使用时自动删除相关指针，从而帮助彻底消除内存泄漏和悬空指针的问题。
它遵循共享所有权的概念，即不同的 shared_ptr 对象可以与相同的指针相关联，并在内部使用引用计数机制来实现这一点。  

•  shared_ptr 创建了一个计数器与类对象所指的内存相关联
•  Copy则计数器加一，销毁则减一

特点:它所指向的资源具有共享性，即多个shared_ptr可以指向同一份资源，并在内部使用引用计数机制来实现这一点。所以不管最终有多少个指针，都是指向的同一个内存

示例： 

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include<Windows.h>  
using namespace std;


//自定义数据类型
class Person {
public:
    Person(string name, int age) {
        mName = name;
        mAge = age;
    }

    Person();

    ~Person()
    {
        cout << "Person 析构函数" << endl;
    }

    void Set_Name(string name)
    {
        this->mName = name;
    }

    void Info()
    {
        std::cout << "name:" << this->mName << endl;
    }

    // 在这里定义一个unique_ptr的别名UniquePtr
    using UniquePtr = unique_ptr<Person>;
public:
    string mName;
    int mAge;
}; 
int main() {

    // 出了{}这个作用域，就会调用Person的析构函数 
    shared_ptr<Person> s1 = make_shared<Person>();
    cout << "s1->count=" << s1.use_count() << endl;// 结果是1

    //Copy则计数器加一 所以不管是s1还是s2，数量都是3
    cout << "copy" << endl;
    shared_ptr<Person> s2 = s1;
    shared_ptr<Person> s3 = s1;
    cout << "s1->count=" << s1.use_count() << endl;// 结果是3
    cout << "s2->count=" << s2.use_count() << endl;// 结果是3
    cout << "s3->count=" << s3.use_count() << endl;// 结果是3

    // 销毁 每销毁一个，计数器减一 所以除了被销毁的结果都是2，
    // 被销毁的s3直接是0
    cout << "s3销毁" << endl; 
    s3 = nullptr;
    cout << "s1->count=" << s1.use_count() << endl;// 结果是2
    cout << "s2->count=" << s2.use_count() << endl;// 结果是2
    cout << "s3->count=" << s3.use_count() << endl;// 结果是0 
     
    return 0;
}

Person::Person()
{
}

 

结果：

 

 

因为指向的都是同一块内存，所以最终调用析构函数的时候也只会调用一次。

 shared_ptr与函数

 值传递

  （1）共享指针在值传递下，方法内部更改内存里的值，同样也会影响方法外部，因为共享指针他们都是指向的同一块内存对象。不管参数加不加const。

示例：

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include<Windows.h>  
using namespace std;  
//自定义数据类型
class Person {
public:
    Person(string name, int age) {
        mName = name;
        mAge = age;
    }

    Person();

    ~Person()
    {
        cout << "Person 析构函数" << endl;
    }

    void Set_Name(string name)
    {
        this->mName = name;
    }

    void Info()
    {
        std::cout << "name:" << this->mName << endl;
    }

    // 在这里定义一个unique_ptr的别名UniquePtr
    using UniquePtr = unique_ptr<Person>;
public:
    string mName;
    int mAge;
}; 
/// <summary>
/// 值传递 共享指针在值传递下，方法内部更改值，同样也会影响方法外部的值
/// </summary>
/// <param name="u"></param>
void pass_value(shared_ptr<Person> u)
{
    u->mName = "值传递";
    u->Info(); 
    cout << "u->count=" << u.use_count() << endl;
}

int main() { 
    shared_ptr<Person> s1 = make_shared<Person>();
    pass_value(s1); 
    s1->Info(); 
    cout << "s1->count=" << s1.use_count() << endl;
    return 0;
}

Person::Person()
{
}

 

结果：

 

 

 在方法内部的数量是2，方法外部是1，是因为值传递，所以就相当于copy了一个新的共享指针，所以在方法内部查看的时候会发现数量为2，但是方法内部执行完成之后这个共享指针就会被释放，所以外部数量就变成了1

 引用传递

 引用传递就不是copy了一个新指针，而是外部的那个指针的地址，所以数量一直为1。

 示例：

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include<Windows.h>  
using namespace std;


//自定义数据类型
class Person {
public:
    Person(string name, int age) {
        mName = name;
        mAge = age;
    }

    Person();

    ~Person()
    {
        cout << "Person 析构函数" << endl;
    }

    void Set_Name(string name)
    {
        this->mName = name;
    }

    void Info()
    {
        std::cout << "name:" << this->mName << endl;
    }

    // 在这里定义一个unique_ptr的别名UniquePtr
    using UniquePtr = unique_ptr<Person>;
public:
    string mName;
    int mAge;
};

// 加const,防止调用unique_ptr的函数，比如说reset，因为执行之后会清空u指向，并且销毁指向内存；
void pass_ref(const  shared_ptr<Person>& u)
{
    u->mName = "引用传递";
    u->Info();    
    cout << "u->count=" << u.use_count() << endl;//
    // 加const之后无法执行下面代码了 就是无法执行指针的内置方法
    //u.reset();
}

int main() {

    shared_ptr<Person> s1 = make_shared<Person>();
    s1->Info();
    pass_ref(s1);

    s1->Info();

    cout << "s1->count=" << s1.use_count() << endl;
    return 0;
}

Person::Person()
{
}

 

 结果：