智能指针——C++

编程语言 2023-05-05 03:55:33 阅读次数: 0

文章目录

1. 为什么需要智能指针？

下面我们先分析一下下面这段程序有没有什么内存方面的问题？
提示一下：注意分析MergeSort函数中的问题:

int div()
{
    
    
    int a, b;
    cin >> a >> b;
    if (b == 0)
        throw invalid_argument("除0错误");
    return a / b;
}
void Func()
{
    
    
    // 1、如果p1这里new 抛异常会如何？
    // 2、如果p2这里new 抛异常会如何？
    // 3、如果div调用这里又会抛异常会如何？
    int* p1 = new int;
    int* p2 = new int;
    cout << div() << endl;
    delete p1;
    delete p2;
 cout << "释放资源" << endl;
}
int main()
{
    
    
    try
    {
    
    
        Func();
    }
    catch (exception& e)
    {
    
    
        cout << e.what() << endl;
    }
    return 0;
}
  1. 一般来说new搭配delete没有问题，但是这里抛了异常，会跨过调用——没有释放。
    从throw直接跳到捕获catch的地方
  2. 更大的问题：连续多个需要抛异常的地方加在一起，前面有些资源有需要释放
    在这里插入图片描述
    在这里插入图片描述

如图所示，此时就没有释放

2. 内存泄漏

2.1 什么是内存泄漏，内存泄漏的危害

什么是内存泄漏：
内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的危害：
长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

void MemoryLeaks()
{
    
    
// 1.内存申请了忘记释放
int* p1 = (int*)malloc(sizeof(int));
int* p2 = new int;
// 2.异常安全问题
int* p3 = new int[10];
Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
delete[] p3;
}

内存泄漏是指针丢了还是内存丢了？
指针丢了！如果指针还在，内存依旧可以释放。内存还在，进程正常结束后，内存也会释放
1、僵尸进程有内存泄漏
2、长期运行的程序

2.2 内存泄漏分类（了解）

C/C++程序中一般我们关心两种方面的内存泄漏：

  • 堆内存泄漏(Heap leak)
    堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
  • 系统资源泄漏
    指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

2.3如何避免内存泄漏

  1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
  2. 采用RAII思想或者智能指针来管理资源
  3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
  4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。

检测工具内部原理：
申请内存用一个容器记录下来
释放内存时，从容器中删除掉
程序结束前或没有任务跑时，容器中的资源可能就是内存泄漏的

总结一下:
内存泄漏非常常见，解决方案分为两种：
1、事前预防型。如智能指针等。
2、事后查错型。如泄漏检测工具。

3.智能指针的使用及原理

3.1 RAII

——获取资源就马上初始化

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。

这种做法有两大·好处·：
1.不需要显式地释放资源。
2.采用这种方式，对象所需的资源在其生命期内始终保持有效利用其他类的生命周期

采用智能指针解决之前内存泄漏的问题：

//利用RAII思想设计delete资源的类
template<class T>
class SmartPtr
{
    
    
public:
    SmartPtr(T* ptr)
        :_ptr(ptr)
    {
    
    }


       ~SmartPtr()
       {
    
    
           cout << "delete:" << _ptr << endl;
           delete _ptr;
       }
private:
    T* _ptr;
};

int div()
{
    
    
    int a, b;
    cin >> a >> b;
    if (b == 0)
        throw invalid_argument("除0错误");
    return a / b;
}


void Func()
{
    
    
    // 1、如果p1这里new 抛异常会如何？
    // 2、如果p2这里new 抛异常会如何？
    // 3、如果div调用这里又会抛异常会如何？
    SmartPtr<int> sp1(new int);
    SmartPtr<int> sp2(new int);
    cout << div() << endl;
    
    cout << "释放资源" << endl;
}
int main()
{
    
    
    try
    {
    
    
        Func();
    }
    catch (exception& e)
    {
    
    
        cout << e.what() << endl;
    }
    return 0;
}

在这里插入图片描述

在这里插入图片描述

如此看来，两者都释放了资源。
这里不管是正常func结束还是抛异常sp1和sp2都会调用析构函数释放资源，很好的解决了问题

以上只是智能指针的基础用法。
还有其他用法：

3.2 智能指针的原理

上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用。

// 2、像指针一样的行为——重载运算符
template<class T>
class SmartPtr
{
    
    
public:
    SmartPtr(T* ptr)
        :_ptr(ptr)
    {
    
    }

    ~SmartPtr()
    {
    
    
        cout << "delete:" << _ptr << endl;
        delete _ptr;
    }

    T& operator*()
    {
    
    
        return *_ptr;
    }

    T* operator->()
    {
    
    
        return _ptr;
    }

private:
    T* _ptr;
};

总结智能指针原理：
1、利用RAII思想设计delete资源的类
2、像指针一样的行为——重载运算符
3、拷贝问题

3.3 std::auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto_ptr来了解它的原理

SmartPtr<A> sp1(new A);
    sp1->_a1++;
    sp1->_a2++;

    //致命问题：拷贝问题——直接报错
SmartPtr<A> sp2(sp1);

sp2需要调用拷贝构造，但我们没写拷贝构造，编译器生成一个默认的，对内置类型浅拷贝，自定义类型拷贝构造
但这里只有一个内置类型：

private:
	T* _ptr;

此时浅拷贝指向同一块空间，析构就会析构两次。如何解决？
方案：
深拷贝解决？不能，违背了功能需求——需要的就是浅拷贝

这种情况和迭代器很像，但是为什么迭代器浅拷贝没有问题？

list<int> lt;
auto it = lt.begin();

迭代器不管理资源释放，只是用统一的方式访问、遍历、修改数据。释放是链表的析构函数处理。

库里的拷贝是没有问题的：

auto_ptr<A> ap1(new A);//出了作用域自己会调析构函数
    ap1->_a1++;
    ap1->_a2++;

auto_ptr<A> ap2(ap1);

怎么解决的？
管理权转移——不负责的拷贝

auto_ptr真正的问题：

auto_ptr<A> ap1(new A);//出了作用域自己会调析构函数
    ap1->_a1++;
    ap1->_a2++;

auto_ptr<A> ap2(ap1);
        ap1->_a1++;
    ap1->_a2++;
        ap2->_a1++;
    ap2->_a2++;

不去访问ap1的时候可以保证释放：
在这里插入图片描述

但是再次去解引用就会发生空指针问题，被拷贝对象悬空

在这里插入图片描述

class A
{
    
    
public:
    ~A()
    {
    
    
        cout << "~A()" << endl;
    }
    //private:
    int _a1 = 0;
    int _a2 = 0;
};

template<class T>
class SmartPtr {
    
    
public:
    SmartPtr(T* ptr = nullptr)
        : _ptr(ptr)
    {
    
    }

    ~SmartPtr()
    {
    
    
        if (_ptr)
        {
    
    
            cout << "Delete:" << _ptr << endl;
            delete _ptr;
        }
    }

    T& operator*()
    {
    
    
        return *_ptr;
    }

    T* operator->()
    {
    
    
        return _ptr;
    }

private:
    T* _ptr;
};

namespace haha
{
    
    
    // C++98  auto_ptr 管理权转移，被拷贝对象的出现悬空问题
    // 很多公司是明确的要求了不能使用它
    template<class T>
    class auto_ptr
    {
    
    
    public:
        auto_ptr(T* ptr = nullptr)
            : _ptr(ptr)
        {
    
    }

        auto_ptr(auto_ptr<T>& ap)
            :_ptr(ap._ptr)
        {
    
    
            ap._ptr = nullptr;
        }

        // ap1 = ap2;
        auto_ptr<T>& operator=(auto_ptr<T>& ap)
        {
    
    
            if (this != &ap)
            {
    
    
                if (_ptr)
                {
    
    
                    cout << "Delete:" << _ptr << endl;
                    delete _ptr;
                }

                _ptr = ap._ptr;
                ap._ptr = nullptr;
            }

            return *this;
        }

        ~auto_ptr()
        {
    
    
            if (_ptr)
            {
    
    
                cout << "Delete:" << _ptr << endl;
                delete _ptr;
            }
        }

        T& operator*()
        {
    
    
            return *_ptr;
        }

        T* operator->()
        {
    
    
            return _ptr;
        }

    private:
        T* _ptr;
    };

void test_auto_ptr()
{
    
    
    std::auto_ptr<A> ap1(new A);
    ap1->_a1++;
    ap1->_a2++;

    std::auto_ptr<A> ap2(ap1);
    ap1->_a1++;
    ap1->_a2++;
    ap2->_a1++;
    ap2->_a2++;

    // 2 2
    cout << ap2->_a1 << endl;
    cout << ap2->_a2 << endl;

    std::auto_ptr<A> ap3(new A);
    ap2 = ap3;

    ap2->_a1++;
    ap2->_a2++;

    cout << ap2->_a1 << endl;
    cout << ap2->_a2 << endl;
}

在这里插入图片描述
 

namespace haha
{
    
    
    
    template<class T>
    class auto_ptr
    {
    
    
    public:
        auto_ptr(T* ptr = nullptr)
            : _ptr(ptr)
        {
    
    }

        auto_ptr(auto_ptr<T>& ap)
            :_ptr(ap._ptr)
        {
    
    
            ap._ptr = nullptr;
        }

        // ap1 = ap2;
        auto_ptr<T>& operator=(auto_ptr<T>& ap)
        {
    
    
            if (this != &ap)
            {
    
    
                if (_ptr)
                {
    
    
                    cout << "Delete:" << _ptr << endl;
                    delete _ptr;
                }

                _ptr = ap._ptr;
                ap._ptr = nullptr;
            }

            return *this;
        }

        ~auto_ptr()
        {
    
    
            if (_ptr)
            {
    
    
                cout << "Delete:" << _ptr << endl;
                delete _ptr;
            }
        }

        T& operator*()
        {
    
    
            return *_ptr;
        }

        T* operator->()
        {
    
    
            return _ptr;
        }

    private:
        T* _ptr;
    };
}

void test_auto_ptr()
{
    
    
    haha::auto_ptr<A> ap1(new A);
    ap1->_a1++;
    ap1->_a2++;

    haha::auto_ptr<A> ap2(ap1);
    //ap1->_a1++;
    //ap1->_a2++;
    ap2->_a1++;
    ap2->_a2++;

    // 2 2
    cout << ap2->_a1 << endl;
    cout << ap2->_a2 << endl;

    haha::auto_ptr<A> ap3(new A);
    ap2 = ap3;

    ap2->_a1++;
    ap2->_a2++;

    cout << ap2->_a1 << endl;
    cout << ap2->_a2 << endl;
}

在这里插入图片描述

 
 

3.4 std::unique_ptr

唯一指针
设计思路：简单粗暴，不让拷贝

    // C++11库才更新智能指针实现
// C++11出来之前，boost搞除了更好用的scoped_ptr/shared_ptr/weak_ptr
// C++11将boost库中智能指针精华部分吸收了过来
// C++11->unique_ptr/shared_ptr/weak_ptr
// unique_ptr/scoped_ptr
// 原理：简单粗暴 -- 防拷贝
 template<class T>
    class unique_ptr
    {
    
    
    private:
        // 防拷贝 C++98
        // 只声明不实现 —— 声明成私有
        //unique_ptr(unique_ptr<T>& ap);
        //unique_ptr<T>& operator=(unique_ptr<T>& ap);
    public:
        unique_ptr(T* ptr = nullptr)
            : _ptr(ptr)
        {
    
    }

        // 防拷贝 C++11
        unique_ptr(unique_ptr<T>& ap) = delete;
        unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;

        ~unique_ptr()
        {
    
    
            if (_ptr)
            {
    
    
                cout << "Delete:" << _ptr << endl;
                delete _ptr;
            }
        }

        T& operator*()
        {
    
    
            return *_ptr;
        }

        T* operator->()
        {
    
    
            return _ptr;
        }

    private:
        T* _ptr;
    };
}
    
// unique_ptr:简单粗暴，不让拷贝 只适用于不需要拷贝一些场景
void test_unique_ptr()
{
    
    
    haha::unique_ptr<A> up1(new A);
    //bit::unique_ptr<A> up2(up1);
    up1->_a1++;
    up1->_a2++;

    haha::unique_ptr<A> up3(new A);
    //up1 = up2;
}

在这里插入图片描述

治标不治本
只适用于不需要拷贝的一些场景

 
 

3.5 std::shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

  1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
  2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
  3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
  4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

以下是需要拷贝的场景

// shared_ptr 需要拷贝的场景
void test_shared_ptr1()
{
    
    
    std::shared_ptr<A> sp1(new A);
    std::shared_ptr<A> sp2(sp1);
    std::shared_ptr<A> sp3(sp1);

    sp1->_a1++;
    sp1->_a2++;
    cout << sp2->_a1 << ":" << sp2->_a2 << endl;
    sp2->_a1++;
    sp2->_a2++;
    cout << sp1->_a1 << ":" << sp1->_a2 << endl;

    std::shared_ptr<A> sp5(new A);
    std::shared_ptr<A> sp6(sp5);

    sp1 = sp5;
    sp2 = sp5;
    sp3 = sp5;

    // 自己给自己赋值
    std::shared_ptr<int> sp4(new int);
    sp4 = sp4;
    sp1 = sp5;
}

在这里插入图片描述

共管的可行思路是：
每个对象释放时，–计数
最后一个析构的对象，释放资源

 
 

//这种写法是不可行的
    //template<class T>
    //class shared_ptr
    //{
    
    
    //public:
    //    shared_ptr(T* ptr = nullptr)
    //        : _ptr(ptr)
    //    {
    
    
    //        ++_count;
    //    }

    //    ~shared_ptr()
    //    {
    
    
    //        if (--_count == 0 && _ptr)
    //        {
    
    
    //            cout << "Delete:" << _ptr << endl;
    //            delete _ptr;
    //        }
    //    }

    //    shared_ptr(shared_ptr<T>& sp)
    //        : _ptr(sp._ptr)
    //    {
    
    
    //        ++_count;
    //    }

    //    T& operator*()
    //    {
    
    
    //        return *_ptr;
    //    }

    //    T* operator->()
    //    {
    
    
    //        return _ptr;
    //    }

    //private:
    //    T* _ptr;

    //    static int _count; // 引用计数
    //};

    //template<class T>
    //int shared_ptr<T>::_count = 0;
template<class T>
    class shared_ptr
    {
    
    
    public:
        shared_ptr(T* ptr = nullptr)
            : _ptr(ptr)
            , _pCount(new int(1))
        {
    
    }

        void Release()
        {
    
    
            if (--(*_pCount) == 0)
            {
    
    
                cout << "Delete:" << _ptr << endl;
                delete _ptr;
                delete _pCount;
            }
        }

        ~shared_ptr()
        {
    
    
            Release();
        }

        // sp1(sp2)
        shared_ptr(const shared_ptr<T>& sp)
            : _ptr(sp._ptr)
            , _pCount(sp._pCount)
        {
    
    
            (*_pCount)++;
        }

        // sp1 = sp5
        // sp1 = sp1
        
        shared_ptr<T>& operator=(const shared_ptr<T>& sp)
        {
    
    
            //if (this == &sp)
            if (_ptr == sp._ptr)
            {
    
    
                return *this;
            }

            // 减减被赋值对象的计数，如果是最后一个对象，要释放资源
            /*if (--(*_pCount) == 0)
            {
            delete _ptr;
            delete _pCount;
            }*/
            Release();

            // 共管新资源，++计数
            _ptr = sp._ptr;
            _pCount = sp._pCount;

            (*_pCount)++;

            return *this;
        }

        T& operator*()
        {
    
    
            return *_ptr;
        }

        T* operator->()
        {
    
    
            return _ptr;
        }

    private:
        T* _ptr;

        // 引用计数
        int* _pCount;
    };
 
 
 // shared_ptr 需要拷贝的场景
void test_shared_ptr1()
{
    
    
    haha::shared_ptr<A> sp1(new A);
    haha::shared_ptr<A> sp2(sp1);
    haha::shared_ptr<A> sp3(sp1);

    sp1->_a1++;
    sp1->_a2++;
    cout << sp2->_a1 << ":" << sp2->_a2 << endl;
    sp2->_a1++;
    sp2->_a2++;
    cout << sp1->_a1 << ":" << sp1->_a2 << endl;

    haha::shared_ptr<A> sp5(new A);
    haha::shared_ptr<A> sp6(sp5);

    sp1 = sp5;
    sp2 = sp5;
    sp3 = sp5;

    // 自己给自己赋值
    haha::shared_ptr<int> sp4(new int);
    sp4 = sp4;
    sp1 = sp5;
}

在这里插入图片描述

静态计数对象，不可以
一个资源，配一个计数，多个智能指针对象共管静态计数对象，所有资源都只有一个计数，因为静态成员属于整个类，属于类的所有对象
每个资源需要管理时，会给构造函数，构造new一个计数。

3.5.1循环引用分析：

  1. node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动
    delete。
  2. node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
  3. node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上
    一个节点。
  4. 也就是说_next析构了，node2就释放了。
  5. 也就是说_prev析构了，node1就释放了。
  6. 但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放

循环引用：

struct Node
{
    
    
    int _val;
    std::shared_ptr<Node> _next;
    std::shared_ptr<Node> _prev;



    ~Node()
    {
    
    
        cout << "~Node" << endl;
    }
};


void test_shared_ptr2()
{
    
    
    std::shared_ptr<Node> n1(new Node);
    std::shared_ptr<Node> n2(new Node);

    n1->_next = n2;//不能赋值过去，自定义对象不能赋值给原生指针
    n2->_prev = n1;

    
}

这个函数结束之后，n2先析构，n1后析构
_next管着右边的节点内存块
_prev管着左边的节点内存块

_next析构，右边节点就delete,_next什么时候释放呢?
左边的节点被delete，调用析构函数，_next作为成员才会析构

_prev析构，左边节点就delete,_prev什么时候释放呢?
右边的节点被delete，调用析构函数，_prev作为成员才会析构

 
 

解决方法：

struct Node
{
    
    
    int _val;    

std::weak_ptr<Node> _next;
std::weak_ptr<Node> _prev;

    ~Node()
    {
    
    
        cout << "~Node" << endl;
    }
};

// 循环引用 -- weak_ptr不是常规智能指针，没有RAII，不支持直接管理资源
// weak_ptr主要用shared_ptr构造，用来解决shared_ptr循环引用问题
void test_shared_ptr2()
{
    
    
    

    std::shared_ptr<Node> n1(new Node);//不支持隐式类型转换
    std::shared_ptr<Node> n2(new Node);

    cout << n1.use_count() << endl;
    cout << n2.use_count() << endl;

    n1->_next = n2;
    n2->_prev = n1;

    cout << n1.use_count() << endl;
    cout << n2.use_count() << endl;
}

在这里插入图片描述

特点：
_next和_prev是weak_ptr时，他不参与资源释放管理，可以访问和修改到资源，但是不增加计数，这样就不存在循环引用的问题了。

模拟实现weak_ptr

   //辅助型智能指针，配合解决shared_ptr的循环引用问题
    template<class T>
    class weak_ptr
    {
    
    
    public:
        weak_ptr()
            :_ptr(nullptr)
        {
    
    }

        weak_ptr(const shared_ptr<T>& sp)
            :_ptr(sp.get())
        {
    
    }

        weak_ptr(const weak_ptr<T>& wp)
            :_ptr(wp._ptr)
        {
    
    }

        weak_ptr<T>& operator=(const shared_ptr<T>& sp)
        {
    
    
            _ptr = sp.get();
            return *this;
        }

        T& operator*()
        {
    
    
            return *_ptr;
        }

        T* operator->()
        {
    
    
            return _ptr;
        }
    public:
        T* _ptr;
    };

 
 

如果不是new出来的对象如何通过智能指针管理呢？其实shared_ptr设计了一个删除器来解决这个问题
new[]内置类型没有问题，自定义类型会报错

template<class T>
struct DeleteArray
{
    
    
    void operator()(T* ptr)
    {
    
    
        cout << "delete[]" << ptr << endl;
        delete[] ptr;
    }
};

template<class T>
struct Free
{
    
    
    void operator()(T* ptr)
    {
    
    
        cout << "free" << ptr << endl;
        free(ptr);
    }
};

// 定制删除器
//void test_shared_ptr3()
//{
    
    
//    // 仿函数对象
//    /*std::shared_ptr<Node> n1(new Node[5], DeleteArray<Node>());
//    std::shared_ptr<Node> n2(new Node);
//
//    std::shared_ptr<int> n3(new int[5], DeleteArray<int>());
//
//    std::shared_ptr<int> n4((int*)malloc(sizeof(12)), Free<int>());*/
//
//    // lambda
//    //std::shared_ptr<Node> n1(new Node[5], [](Node* ptr){delete[] ptr; });
//    //std::shared_ptr<Node> n2(new Node);
//
//    //std::shared_ptr<int> n3(new int[5], [](int* ptr){delete[] ptr; });
//
//    //std::shared_ptr<int> n4((int*)malloc(sizeof(12)), [](int* ptr){free(ptr); });
//    //std::shared_ptr<FILE> n5(fopen("test.txt", "w"), [](FILE* ptr){fclose(ptr); });
//
//    //std::unique_ptr<Node, DeleteArray<Node>> up(new Node[5]);
//}

void test_shared_ptr3()
{
    
    
    haha::shared_ptr<Node, DeleteArray<Node>> n1(new Node[5]);
    haha::shared_ptr<Node> n2(new Node);
    haha::shared_ptr<int, DeleteArray<int>> n3(new int[5]);
    haha::shared_ptr<int, Free<int>> n4((int*)malloc(sizeof(12)));
}

 
 

4.C++11和boost中智能指针的关系

  1. C++ 98 中产生了第一个智能指针auto_ptr.
  2. C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr.
  3. C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版。
  4. C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。

猜你喜欢

转载自blog.csdn.net/Ll_R_lL/article/details/128905227
今日推荐
富文本编辑器 Quill 2.0 重磅发布，特性、可靠性与开发者体验大幅提升
“开源信徒”周鸿祎开源360智脑大模型
周排行
Ubuntu 14.04 下Fuel6.0安装部署
香港一小巴侧翻致1死16伤 警方：未见机件故障
pikachu--XSS盲打
阅读 深入理解JVM虚拟机笔记一
java.sql.SQLException: ORA-00932: 数据类型不一致: 应为 -, 但却获得 CLOB
oracle delete all object under an user
[LeetCode]20 Valid Parentheses 有效的括号
树形DP求树的直径 【模板】
Context propagation over HTTP in Go
【PAT】（B）1053 住房空置率 (20)*
每日归档
更多
2024-04-18(0)
2024-04-17(5)
2024-04-16(70)
2024-04-15(42)
2024-04-14(0)
2024-04-13(119)
2024-04-12(38)
2024-04-11(14)
2024-04-10(68)
2024-04-09(5)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022