20_智能指针

shared_ptr

1. 自动内存管理：shared_ptr通过引用计数机制自动管理内存。当最后一个shared_ptr指向的对象被销毁时，它会自动释放所管理的内存资源，从而避免内存泄漏
2. 共享所有权：shared_ptr允许多个指针实例共享同一资源的所有权。这意味着多个shared_ptr可以安全地指向同一个对象，而不必担心释放内存时的同步问题
3. 异常安全：在异常发生时，shared_ptr确保动态分配的内存得到释放，这有助于防止由于异常导致的资源泄漏
4. 减少程序崩溃：shared_ptr避免了野指针和重复释放内存的问题，这些问题可能导致程序崩溃
5. 便于资源共享：在需要多个对象之间共享数据时，shared_ptr提供了一种避免拷贝造成的开销的方法
6. 自定义删除器：shared_ptr允许指定自定义删除器，这在管理非标准资源时非常有用，例如当需要特殊方式释放资源时

使用shared_ptr需要注意的是，虽然它提供了很多便利，但也会带来一定的性能开销，因为它需要维护引用计数。因此，在不需要共享所有权的场景下，过度使用shared_ptr可能会影响程序性能

智能指针的调试

#include<iostream>
#include<memory>

class ClassA
{
public:
        ClassA(int n)
        {
                num = n;
                printf("ClassA\n");
        }

        ~ClassA()
        {
                printf("~ClassA\n");
        }
public:
        int num = 0;
};


void fun(std::shared_ptr<ClassA>& pA)
{//引用计数  
        pA->num++;

        std::cout << pA.use_count() << pA->num << std::endl;
}

void fun2(std::shared_ptr<ClassA> pA)
{//引用计数  
        pA->num++;

        std::cout << pA.use_count() << pA->num << std::endl;
}

int main()
{
        std::shared_ptr<ClassA> pA = std::make_shared<ClassA>(10);
        std::cout << pA.use_count() << pA->num << std::endl;
        fun(pA);
        std::cout << pA.use_count() << pA->num << std::endl;
        fun2(pA);
        std::cout << pA.use_count() << pA->num << std::endl;
        return 0;
}

智能指针的效率

#include"Alloctor.h"
#include<stdlib.h>
#include<iostream>
#include<thread>
#include<mutex>//锁
#include<memory>
#include"CELLTimestamp.hpp"
using namespace std;
//原子操作   原子 分子 
mutex m;
const int tCount = 8;
const int mCount = 100000;
const int nCount = mCount/tCount;
void workFun(int index)
{
    char* data[nCount];
    for (size_t i = 0; i < nCount; i++)
    {
        data[i] = new char[(rand()%128)+1];
    }
    for (size_t i = 0; i < nCount; i++)
    {
        delete[] data[i];
    }
}//抢占式

class ClassA
{
public:
    ClassA(int n)
    {
        num = n;
        printf("ClassA\n");
    }

    ~ClassA()
    {
        printf("~ClassA\n");
    }
public:
    int num = 0;
};


ClassA& fun(ClassA& pA)
{//引用计数  
    pA.num++;
    return pA;
}

void fun(shared_ptr<ClassA>& pA)
{//引用计数  
    pA->num++;
}

void fun(ClassA* pA)
{//引用计数  
    pA->num++;
}

int main()
{
    /*
    thread t[tCount];
    for (int n = 0; n < tCount; n++)
    {
        t[n] = thread(workFun, n);
    }
    CELLTimestamp tTime;
    for (int n = 0; n < tCount; n++)
    {
        t[n].join();
        //t[n].detach();
    }
    cout << tTime.getElapsedTimeInMilliSec() << endl;
    cout << "Hello,main thread." << endl;
    */

    /*
    int* a = new int;
    *a = 100;
    delete a;
    //printf("a=%d\n", *a);
    //C++标准库智能指针的一种
    shared_ptr<int> b = make_shared<int>();
    *b = 100;
    //printf("b=%d\n", *b);
    */
    {
        shared_ptr<ClassA> b = make_shared<ClassA>(100);
        b->num = 200;
        CELLTimestamp tTime;
        for (int n = 0; n < 100000000; n++)
        {
            fun(b);
        }
        cout << tTime.getElapsedTimeInMilliSec() << endl;
    }
    {
        ClassA* b = new ClassA(100);
        b->num = 200;
        CELLTimestamp tTime;
        for (int n = 0; n < 100000000; n++)
        {
            fun(b);
        }
        cout << tTime.getElapsedTimeInMilliSec() << endl;
    }
    return 0;
}