C++ 几种智能指针的简单实现

最新推荐文章于 2023-03-10 16:10:57 发布
最新推荐文章于 2023-03-10 16:10:57 发布
阅读量755 收藏 1
点赞数
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alick97/article/details/52921615
版权

#pragma once

// 智能指针 

// 定义个类来封装资源的分配和释放，在构造 函数完成资源的分配和初始化，在析构函数完成资源的

// 清理，可以 保证资源的正确初始化和释放。

// 这里简单实现 AutoPtr、 ScopedPtr、ScopedArray以及 SharedPtr


 //------------------------------SmartPtr.h-------------------

template<typename T>

class AutoPtr //缺点 定义多个指向同一空间的ptr 只有一个控制 其他的都失效了 

{

public:

    AutoPtr(T* ptr = NULL)

        :_ptr(ptr)

    {}


    AutoPtr(AutoPtr<T>& ap)// 这里没有用const 为了修改ap的成员

        :_ptr(ap._ptr)

    {

        ap._ptr = NULL;// 只能有一个智能指针 指向空间 （控制权）

    }

    

    AutoPtr<T>& operator= (AutoPtr<T>& ap)

    {

        if(_ptr != ap._ptr)//排除 1 自赋值 2（常常会忽略） 虽然不是自赋值 但两个的_ptr 指向同一空间

        {

            //第3种情况 两个不指向同一空间

            delete _ptr;

            _ptr = ap._ptr;

            ap._ptr = NULL;


            return *this;

        }

    }


    ~AutoPtr()

    {

        if(_ptr)

        {

            cout<<"delete _ptr"<<_ptr<<endl;

            delete _ptr;

        }

    }


    T& operator*()

    {

        return *_ptr;

    }

    // 从原理来说 要两个-> 

    // operator->（）返回的是T* 再->才能访问对应成员

    // 这里编译器做了处理

    // 如 operator++() operator++(int)

    T* operator->()

    {

        return _ptr;

    }


protected:

    T* _ptr;

};


void testAutoPtr()

{


    struct A

{

    int _a;

};


    AutoPtr<int> ap1(new int(1));

    AutoPtr<int> ap2(ap1);

    AutoPtr<int> ap3(new int(2));

    ap3 = ap2;


    *ap3 = 10;//运算符重载T& operator*()


    A* p4 = new A;

    p4->_a = 10;


    AutoPtr<A> ap4(new A);//运算符重载 T* operator->()

    ap4->_a = 4;

}



//  AutoPtr 的老版本的写法 比之前的多了一个bool 类型的_owner

// 缺点 ： 在 

// AutoPtr<int> ap1(new int (1)); 

//if (1)

// {

//        AutoPtr<int> ap2(ap1);

// }

// 这种场景下 ap2出了作用域 析构 释放空间 但ap1指针还指向那块空间 很危险（野指针）


template<typename T>

class AutoPtr

{

public:

AutoPtr(T* ptr = NULL)

        :_ptr(ptr)

    {}


AutoPtr(AutoPtr<T>& ap)

{

_ptr = ap._ptr;

_owner = true;

ap._owner = false;

}


~AutoPtr()

{

if (_owner)

{

delete _ptr;

_owner = false;

}

}


AutoPtr<T>& operator=(AutoPtr<T>& ap)

    {

        if(_ptr != ap._ptr)//排除 1 自赋值 2（常常会忽略） 虽然不是自赋值 但两个的_ptr 指向同一空间

        {

            //第3种情况 两个不指向同一空间

if (_owner == true)

{

delete _ptr;

}

_ptr = ap._ptr;

ap._owner = false;

_owner = true;

            return *this;

        }

    }


 

    T& operator*()

    {

        return *_ptr;

    }


T* operator->()

    {

        return _ptr;

    }


protected:

T* _ptr;

bool _owner;


};


void testAutoPtr()

{


    struct A

{

int _a;

};


    AutoPtr<int> ap1(new int(1));

    AutoPtr<int> ap2(ap1);

    AutoPtr<int> ap3(new int(2));

    ap3 = ap2;


    *ap3 = 10;//运算符重载T& operator*()


    A* p4 = new A;

    p4->_a = 10;


    AutoPtr<A> ap4(new A);//运算符重载 T* operator->()

    ap4->_a = 4;

}

//-----------------------------------------------------

template<typename T>

class ScopedPtr //缺点 不能解决 两个对象之间的拷贝 

{

public:

    ScopedPtr(T* ptr = NULL)

        :_ptr(ptr)

    {}


    ~ScopedPtr()

    {

        if (_ptr)

        {

            cout<<"delete:"<<_ptr<<endl;

            delete _ptr;

        }

    }


    T& operator*()

    {

        return *_ptr;

    }


    T* operator->()

    {

        return _ptr;

    }


    //与AutoPtr相比 简单 粗暴 直接加protected:防止拷贝构造和赋值重载 同时也防止别人在类外实现

protected:

    ScopedPtr(ScopedPtr<T>& sp);

    ScopedPtr<T>& operator=(ScopedPtr<T>& sp);


protected:

    T* _ptr;

};


void TestScopedPtr()

{

    ScopedPtr<int> sp1(new int(1));

   // ScopedPtr<int> sp2(sp1);

}


//------------------------------------------

template<typename T>

class SharedPtr

{

public:

    SharedPtr(T* ptr = NULL)

        :_ptr(ptr)

        ,_pCount(new long(1))

    {}


    ~SharedPtr()

    {

        _Release();

    }


    SharedPtr(const SharedPtr<T>& sp)

        :_ptr(sp._ptr)

        ,_pCount(sp._pCount)

    {

        ++(*_pCount);

    }

/************************************

   SharedPtr<T>& operator=(const SharedPtr<T>& sp)

   {

       // 考虑多种情况

       // 1 sp1 = sp1

       // 2 sp1 = sp2; ==>sp1,sp2管理着同一块内存

       // 3 sp1 = sp3 sp1与sp3 指向的空间不同


       if (_ptr != sp._ptr)//排除1、 2

       {

  _Release();


  _ptr = sp._ptr;

  _pCount = sp._pCount;

  (*_pCount)++;

       }


        return *this;

   }

   ***************************************/


SharedPtr<T>& operator=(SharedPtr<T> sp)//不用引用 不用const

   {

      //现代 写法

  swap(_ptr, sp._ptr);

  swap(_pCount, sp._pCount);


        return *this;

   }

wKiom1b9FuCCs3CyAAHZbScBavs620.bmp


   T& operator*()

   {

return *_ptr;

   }


   T* operator->()

   {

return _ptr;

   }


   long UseCount()

   {

return *_pCount;

   }


   T* GetPtr()

   {

return _ptr;

   }



protected:

void _Release()

{

if(--(*_pCount) == 0)

{

delete _ptr;

delete _pCount;

}

}


protected:

    T* _ptr;

    long* _pCount;

};


void TestSharedPtr()

{

    SharedPtr<int> sp1(new int(1));

    SharedPtr<int> sp2(sp1);

    SharedPtr<int> sp3(sp1);


   // int a;

   // const int* p = &a;

    int const * p = &a;

   // // error: (*p) = 1; 要是可修改的左值

   // // p = &a;

    int * p2 = p; // error  不能从const到非const


   // int * const p3 = &a;

   error  p3 = &a;要是可修改的左值

   // *p3 = 5;


cout<<"sp1:"<<sp1.UseCount()<<endl;

cout<<"sp2:"<<sp2.UseCount()<<endl;

cout<<"sp3:"<<sp3.UseCount()<<endl<<endl;


sp1 = sp1;

sp1 = sp2;


cout<<"sp1:"<<sp1.UseCount()<<endl;

cout<<"sp2:"<<sp2.UseCount()<<endl;

cout<<"sp3:"<<sp3.UseCount()<<endl<<endl;


SharedPtr<int> sp4(new int(2));

sp1 = sp4;


cout<<"sp1:"<<sp1.UseCount()<<endl;

cout<<"sp2:"<<sp2.UseCount()<<endl;

cout<<"sp3:"<<sp3.UseCount()<<endl;

cout<<"sp4:"<<sp4.UseCount()<<endl;


}


//-----------------------------------------------------

template<typename T>

class ScopedArray

{

public:

ScopedArray(T* ptr = NULL)

:_ptr(ptr)

{}


~ScopedArray()

{

if (_ptr)

{

delete[] _ptr;

}

}


/*T& operator*()

{

return *_ptr;

}


T* operator->()

{

return _ptr;

}*/

//不需要重载上面两个 用operator[]


T& operator[](size_t index)

{

return _ptr[index];

}

protected:

ScopedArray(const ScopedArray<T>& sp);

ScopedArray<T>& operator=(const ScopedArray<T>& sp);


protected:

T* _ptr;

};


void TestScopedArray()

{

struct V

{

int _v;

};


ScopedArray<V> sa(new V[10]);

sa[0]._v = 1;

sa[2]._v = 11;

}


//-----------------------------test.cpp--

#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>

using namespace std;


#include "SmartPtr.h"


//void Test1()

//{

//    int* p = new int(1);

//

//    if (1)

//    {

//        delete p;

//

//        return;

//    }

//    delete p;

//}

//void DoSomething()

//{

//    if (1)

//    {

//        throw 1;

//    }

//}

//

//void Test2()

//{

//    int* p = new int(1);

//    try

//    {

//        DoSomething();

//    }

//    catch(...)

//    {

//        delete p;

//        throw;

//    }

//

//    delete p;

//}

//

//void Test1()

//{

//    int* p = new int(1);

//    AutoPtr<int> ap(p);

//    if (1)

//    {

//       // delete p;

//

//        return;

//    }

//   // delete p;

//}

//void DoSomething()

//{

//    if (1)

//    {

//        throw 1;

//    }

//}

//

//void Test2()

//{

//    int* p = new int(1);

//    AutoPtr<int> ap(p);

//

//    DoSomething();

//    /*try

//    {

//        DoSomething();

//    }

//    catch(...)

//    {

//        delete p;

//        throw;

//    }

//

//    delete p;*/

//}

//

//int main()

//{

//    try

//    {

//        Test1();

//        Test2();

//    }

//    catch(...)

//    {

//        cout<<"未知异常"<<endl;

//    }

//

//    getchar();

//    return 0;

//}





int main()

{

    

    //TestSharedPtr();


TestScopedArray();


getchar();

    return 0;

}

//==================================

//==================================

//==================================

// 续

//1、 增加AutoPtr的另一种写法（老版本写法）

//2、 模拟SharedPtr的定置删除器

//3、 定置删除器和循环引用的场景并理解


// 智能指针 使用库中的 



#include <memory> // 这个头文件包含 auto_ptr 、unique_ptr 、shared_ptr

using namespace std;


void test_auto_ptr()

{

//auto_ptr 用到 memory头文件

auto_ptr<int> ap1(new int(1));

auto_ptr<int> ap2(ap1);

}


// scoped_ptr 在 C++ 11 中叫 unique_ptr

void test_scoped_ptr()

{

unique_ptr<int> sp1(new int(1));

// error unique_ptr<int> sp2(sp1);

}


void test_shared_ptr1()

{

shared_ptr<int> sp1(new int (1));

cout<<"sp1:"<<sp1.use_count()<<endl;

shared_ptr<int> sp2(sp1);

cout<<"sp1:"<<sp1.use_count()<<endl;

cout<<"sp2:"<<sp2.use_count()<<endl;

}


//--------------------------------------------------

void test_shared_ptr2()

{

struct Node

{

//Node* _next;

//Node* _prev;

shared_ptr<Node> _next; // 容易引起循环引用 解决方法详见 下面weak_ptr

shared_ptr<Node> _prev;

~Node()

{

cout<<"delete:"<<this<<endl;

}

};

//  循环引用问题 这几步都用的是 智能指针 cur next _next _prev

shared_ptr<Node> cur(new Node());

shared_ptr<Node> next(new Node());

// 没有下面两句就可以释放的 下面两句引起循环引用

// *********重点***********

//cur->_next = next;

//next->_prev = cur;

// 分析 循环引用 原因 图


wKioL1cFIJWCmTltAACqczONHcA770.png

}


// 解决循环引用问题 weak_ptr


void test_shared_ptr3()

{

struct Node

{

//Node* _next;

//Node* _prev;

/*shared_ptr<Node> _next;

shared_ptr<Node> _prev;*/

// 解决循环引用 （运用弱指针weak_ptr 不增加shared_ptr的count 增加自己weak_ptr 的引用计数 count）

//weak_ptr 重载了operator->() operator*()

// weak_ptr 唯一的目的 就是解决shared_ptr的死穴 循环引用问题 

// wead_ptr不能单独使用 例如没有weak_ptr<int> (int*)类型的构造函数 只有weak_ptr<shared_ptr> (shared_ptr&)

// 用弱指针 场景 内部含有指向对方的 智能指针

weak_ptr<Node> _next;

weak_ptr<Node> _prev;



~Node()

{

cout<<"delete:"<<this<<endl;

}

};

//  循环引用问题 这几步都用的是 智能指针 cur next _next _prev

shared_ptr<Node> cur(new Node());

shared_ptr<Node> next(new Node());

cout<<"cur"<<cur.use_count()<<endl;

cout<<"next:"<<next.use_count()<<endl;

// *********重点**** weak_ptr解决循环引用问题 *******

cur->_next = next;

next->_prev = cur;

cout<<"cur"<<cur.use_count()<<endl;

cout<<"next:"<<next.use_count()<<endl;


}

wKioL1cFIWXBTDMaAAERVnah6ng378.png

//--------------------------------------------------------------------

// 仿函数

// 原理: 重载operator() ()

// 使用： 用Less创建一个结构体对象less

// 使用less() 看起来像函数调用 其实是使用了对象的operator（）操作 这样传参传如一个less对象就能用它的对应的operator（）方法 这样就能定制删除器了

template<typename T>

struct Less 

{

bool operator() (const T& L, const T& R)

{

return L < R;

}

};


void test_less()

{

Less<int> less;

cout<<less(1, 2)<<endl;

}


//------------------------------

//模拟SharedPtr的定置删除器

void test_shared_ptr4()

{

//场景1 没问题

int* p1 = (int*)malloc(sizeof(int) * 10);

shared_ptr<int> sp1(p1);


// 场景2  析构出错 不能将FILE* 转换为int*

//FILE* p2 = fopen("test.txt", "r");

//shared_ptr<int> sp2(p2);

}


// 定制删除器

struct Free

{

void operator()(void* ptr)

{

cout<<"Free:"<<ptr<<endl;

free(ptr);

}

};


struct FileClose //场景2的 删除器

{

void operator()(void* fp)

{

cout<<"FileClose:"<<fp<<endl;

if (fp != NULL)

{

fclose((FILE*)fp);

}

}

};


void test_Free()

{

//场景1 没问题

int* p1 = (int*)malloc(sizeof(int) * 10);

// ***********  重点 定制删除器的应用

// Free() 创建一个匿名对象

shared_ptr<int> sp1(p1, Free()); // 重点 【给库中的 shared_ptr 传入 Free()的匿名对象】 下边改进的自己的SharedPtr也用到这方法


// 场景2  析构出错 不能将FILE* 转换为int*

// 定制删除器后不出错

FILE* p2 = fopen("test.txt", "r");

shared_ptr<FILE> sp2(p2, FileClose());

}

//---------------------------------


//用定制删除器 改进 之前的SharedPtr

template<typename T, typename D = DefaultDel<T>>//D 是删除器结构体类型

class SharedPtr

{

public:

    SharedPtr(T* ptr = NULL)

        :_ptr(ptr)

        ,_pCount(new long(1))

    {}


SharedPtr(T* ptr, D del)

:_ptr(ptr)

,_pCount(new long(1))

,_del(del)

{}


    ~SharedPtr()

    {

        _Release();

    }


    SharedPtr(const SharedPtr<T, D>& sp)

        :_ptr(sp._ptr)

        ,_pCount(sp._pCount)

    {

        ++(*_pCount);

    }



SharedPtr<T, D>& operator=(SharedPtr<T,D> sp)//不用引用 不用const

   {

      //现代 写法

  swap(_ptr, sp._ptr);

  swap(_pCount, sp._pCount);


        return *this;

   }


   T& operator*()

   {

return *_ptr;

   }


   T* operator->()

   {

return _ptr;

   }


   long UseCount()

   {

return *_pCount;

   }


   T* GetPtr()

   {

return _ptr;

   }



protected:

void _Release()

{

if(--(*_pCount) == 0)

{

//delete _ptr;

//********更换成——del（）************

_del(_ptr);

delete _pCount;

}

}


protected:

    T* _ptr;

    long* _pCount;

D _del;

};


// 删除器

template<typename T>

struct DefaultDel

{

void operator()(T* ptr)

{

delete ptr;

}

};

template<typename T>

struct FreeShared

{

void operator()(T* ptr)

{

free(ptr);

}

};


void TestDeleter()

{

SharedPtr<int, DefaultDel<int>> sp1(new int(10));

SharedPtr<int, FreeShared<int>> sp2((int*)malloc(sizeof(int) * 2));


SharedPtr<int> sp3(new int(1));

}


//-----------------------------------------------------


#include "SmartPtr.h"

int main()

{

//test_auto_ptr();

//test_shared_ptr4();

//test_less();

test_Free();

//TestDeleter();


getchar();

return 0;

}


本文出自 “城市猎人” 博客，请务必保留此出处http://alick.blog.51cto.com/10786574/1758966

alick97
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11 智能指针之shared_ptr代码详解
12-17
C++中的智能指针首先出现在“准”标准库boost中。 随着使用的人越来越多，为了让开发人员更方便、更安全的使用动态内存，C++11也引入了智能指针来管理动态对象。 在新标准中，主要提供了shared_ptr、unique_ptr、...
C++ 四种智能指针详解
MusicMan
11-30 3835
智能指针出现的原因：主要解决的是堆内存分配释放，忘记释放内存引发的内存泄漏问题，智能指针最主要的事情就是让程序员无需去注意内存释放，内存释放的问题放在智能指针内部进行处理。 智能指针有四种，包括auto_ptr,shared_ptr,unique_ptr,weak_ptr,其中auto_ptr已经被C++11废弃，所以放在最后介绍。 unique_ptr unique_ptr的几个重要特性：...
常见的智能指针
m0_60492395的博客
09-08 1153
三种常用的智能指针
总结四类智能指针
Ahuier21
07-19 839
智能指针的理解 auto_ptr shared_ptr
C++智能指针详解
热门推荐
locahuang的博客
07-23 3万+
1、概述 我们知道除了静态内存和栈内存外，每个程序还有一个内存池，这部分内存被称为自由空间或者堆。程序用堆来存储动态分配的对象即那些在程序运行时分配的对象，当动态对象不再使用时，我们的代码必须显式的销毁它们。 在C++中，动态内存的管理是用一对运算符完成的：new和delete。 new：在动态内存中为对象分配一块空间并返回一个指向该对象的指针; delete：指向一个动态独享的指针，销毁对象，并释放与之关联的内存。 动态内存管理经常会出现两种问题： （1）一种是忘记释放内存，会造成内存泄漏； （2）一..
【C++实现智能指针】
weixin_43273308的博客
06-21 313
智能指针，C++实现shared_ptr和unique_ptr
C++课程作业-基于Qt实现的链表操作演示系统源码(含详细注释+报告).zip
最新发布
12-20
C++课程作业-基于Qt实现的链表操作演示系统源码(含详细注释+报告).zip 1.1 题目 分别以单链表、循环链表、双向链表为例，实现线性表的建立、插入、删除、查找等基 本操作。 要求：能够把建立、插入、删除等基本操作...
c++ primer 第5版（李普曼） part3
07-31
其他一些新特性，例如智能指针和允许移动的容器，允许我们编写更为复杂的类，而又不必与错综复杂的资源管理做斗争。因此，在本书中开始讲授如何编写自己的类，会比第4版简单得多。旧标准中阻挡在我们前进路上的很多...
C++标准库介绍.pdf
08-30
5个智能指针学习智能指针必读份不错参考是来自CUJ文章: Smart Poers in Boost,哦这篇文章可以查到CUJ是提供在线浏览中文版见笔者在Dr.Dobb\'s Journal软件 Software研发杂志第7辑上译文 　Boost总体来说是实用价值很...
c++面试题基础分享.doc
03-24
7.智能指针 8.简述深拷贝和浅拷贝的区别 9.编写my_strcpy函数，实现与库函数strcpy类似的功能，不能使用任何库函数 10.请讲述堆和栈的区别 11.全局变量和局部变量有什么区别？实怎么实现的？操作系统和编译器是...
C++中的智能指针有哪些？分别解决的问题以及区别？
敖丙007的博客
03-10 1172
可以看到fun函数中pa，pb之间互相引用，两个资源的引用计数为2，当要跳出函数时，智能指针pa，pb析构时两个资源引用计数会减一，但是两者引用计数还是为1，导致跳出函数时资源没有被释放（AB的析构函数没有被调用），如果把其中一个改为weak_ptr就可以了，我们把类A里面的shared_ptrpb_;运行结果如下，这样的话，资源B的引用开始就只有1，当pb析构时，B的计数变为0，B得到释放，B释放的同时也会使A的计数减一，同时pa析构时使A的计数减一，那么A的计数为0，A得到释放。
C++11中智能指针的原理、使用、实现
weixin_30367873的博客
05-08 6058
目录 理解智能指针的原理 智能指针的使用 智能指针的设计和实现 1.智能指针的作用 C++程序设计中使用堆内存是非常频繁的操作，堆内存的申请和释放都由程序员自己管理。程序员自己管理堆内存可以提高了程序的效率，但是整体来说堆内存的管理是麻烦的，C++11中引入了智能指针的概念，方便管理堆内存。使用普通指针，容易造成堆内存泄露（忘记释放），二...
学习-＞C++篇十九：四种智能指针及其实现
u014801954的博客
12-21 1277
目录 为什么需要智能指针？ 什么是内存泄露？ 如何避免内存泄露？ 什么是RAII？ RAII有什么用？ 智能指针的原理是什么？ C++的智能指针有哪些？ auto_ptr unique_ptr shared_ptr weak_ptr
C++ 智能指针
liu094的博客
02-01 922
智能指针
c++中的四种智能指针
weixin_44378800的博客
07-08 293
原始指针：通过new建立的*指针 智能指针：通过智能指针关键字（unique_ptr, shared_ptr ，weak_ptr）建立的指针 智能引出的目的是为了解决c++中内存空间管理的问题： 1、申请的空间在函数结束时忘记释放，造成内存泄漏； 2、尚有指针引用内存的情况下就释放了它，就会产生引用非法内存的指针。 使用智能指针可以很大程度上的避免这个问题，因为智能指针是一个类，当超出了类的作用域时，类会自动调用析构函数，析构函数会自动释放资源。所以智能指针的作用原理就是在函数结束时自动释放内存空间，不需要
C++ 中的四个智能指针
Runnymmede的博客
02-09 441
智能指针的一大优点就是可以在对象离开作用域时，自动释放该对象，所以就有了自定义析构对象的需求。
（十一）C++的四种智能指针
sunatmine的博客
11-09 1190
C++的标准模板库STL一共提供了四种智能指针，分别是auto_ptr、unique_ptr、shared_ptr、weak_ptr。它们的作用就是提我们管理动态内存分配。说简单点，就是怕你new/new[]了新的对象，然后忘记释放或者程序出现问题提前终止导致未运行到delete/delete[]，造成内存泄露。 所以如果只能能自己释放内存就好了。。。这就是智能指针存在的意义。智能指针实际是个类对象，它管理一个指针（真正意义上的指针），在类对象失效（超出作用范围）时，调用类对象的析构函数时，自动释放它指向的
C++四种智能指针详解
qq_37535749的博客
02-04 1267
四种智能指针：shared_ptr，unique_ptr，weak_ptr，auto_ptr C++里面的四个智能指针：shared_ptr，unique_ptr，weak_ptr，auto_ptr其中前三个是c++11支持，并且最后一个已经被11弃用。 智能指针的使用 智能指针主要用于管理在堆上分配的内存，它将普通的指针封装为一个栈对象。当栈对象的生存周期结束后，会在析构函数中释放掉申请的内存，从而防止内存泄漏。C++11中最常用的智能指针类型为 shared_ptr它采用引用计数的方法，记录当前内存资源
C++标准中常用的4类智能指针
hsy12342611的专栏
07-23 626
C++标准中的4类智能指针1. 智能指针分类 1.1 auto_ptr 1.2 shared_ptr 1.3 unique_ptr 1.4 weak_ptr 其中1是C++98的方案，2，3，4是C++2.0引入的，auto_ptr采用copy语义来转移指针资源，转移指针资源的所有权的同时将原指针置为NULL，这跟通常理解的copy行为是不一致的(不会修改原数据)，而这样的行为在有些场合下不是我们希望看到的。 比如在STL中，有很多将现有元素复制到某个局部临时对象中，但对于auto_ptr，却将原元素置为n
请介绍 C++ 中的几种智能指针和它们的差别和用法
07-22
C++ 中的几种智能指针包括： 1. shared_ptr：shared_ptr 是一种引用计数智能指针。它通过记录有多少个 shared_ptr 共享同一块内存来管理资源的生命周期。每当创建一个 shared_ptr 时，引用计数会增加；当一个 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值