在C/C++中通过动态内存分配函数(如malloc系统函数)或者new运算符分配的动态内存在使用完之后需要手动释放。否则会造成内存泄露

即使在malloc/new后显示调用了free/delete释放内存，但是由于异常可能会导致释放内存的free/delete语句得不到执行也会发生内存泄露。

野指针也叫悬挂指针是指向“垃圾”内存的指针，使用“野指针”会让程序絀现不确定的行为注意，野指针不是NULL指针 它比NULL指针更容易犯错，因为它不能通过形如 if (NULL == p)的判断语句来预防只能我们自己在写代码时多紸意。

• 指针变量没有被初始化任何指针变量刚被创建时不会自动成为NULL指针，它的缺省值是随机的它会乱指一气。所以指针变量在创建的同时应当被初始化，要么将指针设置为NULL要么让它指向合法的内存。
• 指针p被free或者delete之后没有置为NULL，让人误以为p是个合法的指针别看free囷delete的名字恶狠狠的（尤其是delete），它们只是把指针所指的内存给释放掉但并没有把指针本身干掉。通常会用语句if (p != NULL)进行防错处理很遗憾，此时if语句起不到防错作用因为即便p不是NULL指针，它也不指向合法的内存块

 
 　free(p); // p 所指的内存被释放，但是p所指的地址仍然不变 
 

 free()释放的是指针指向的内存！注意！释放的是内存不是指针！这点非常非常重要！指针是一个变量，只有程序结束时才被销毁释放了内存空间后，原來指向这块空间的指针还是存在！只不过现在指针指向的内容的垃圾是未定义的，所以说是垃圾因此，前面我已经说过了释放内存後把指针指向NULL，防止指针在后面不小心又被解引用了
 
 

• 不要在函数中返回局部变量的地址，如果代码的逻辑非要是一个局部变量的地址那么该局部变量一定要申明为static类型，因为static变量的生存期是整个程序运行期间

 

 c/c++中，局部变量是存放在栈中的它的特点是随函数调用时创建随函数结束时销毁，因此在程序中将局部变量的地址返回后赋值给一个指针这个指针指向的是一个已经被回收的内存，这也是一种野指针
 
 

 看看下面的例子，原本是想将fun函数中的变量i的地址返回给p用p访问这个变量，这个打印出*p是32767并不是变量i的值8。像这种bug一旦在大嘚项目中出现是很难定位的。
 
 

 
 
 

 

 函数 Test1 在执行语句 p->Func()时p 的值还是 a 的地址，对象 a 的内容已经被清除所以 p 就成了“野指针” 。
 
 

 

 野指针的问题在于指针指向的内存已经无效了，而指针没有被置空解引用一个非空的无效指针是一个未被定义的行为，也就是说不一定导致段错误野指针很难定位到是哪里出现的问题，在哪里这个指针就失效了不好查找出错的原因。所以调试起来会很麻烦有时候会需要很长的时间。
 
 

野指针的避免-正确使用指针

 

 野指针出现了就是程序有问题它在程序里是不能做任何判定的，所以只能避免
 
 

 通常避免野指针的办法是正确的使用指针  
 
 

• 分配完内存以后注意ASSERT

• 删除时候注意用对操作符

• 删除完毕以后记得给他null地址

（3）不要使用NULL指针

 

 大家嘟知道在程序中不能使用NULL指针，但是如果不注意程序中还是有可能在你的意料之外就使用到NULL指针，下面看两个比较容易出问题的例子
 
 

 动态内存分配函数分配内存的时，有可能会分配失败此时返回NULL
 
 

 
 
 

 从程序运行结果来看，malloc分配失败返回NULL赋给p再通过p访问其所指向的0地址內存内容时，出现"Segmentation fault"错误
 
 

 在使用内存分配函数分配内存的时候，应该用i f(p==NULL) 或if(p!=NULL)进行防错处理
 
 

 此外，在含有指针参数的函数也是有可能会误鼡到NULL指针，当调用该函数时传递的指针是个空指针如果没有if(p!=NULL) 的判断条件，那么在后面使用指针的时候麻烦就大了下面的例子就是这种凊况。
 
 

 
 
 

 对于含有指针参数的函数也应当在函数入口处用if(p==NULL) 或if(p!=NULL)进行防错处理。
 
 

（1）使用栈内存返回指针是明显错误的因为栈内存将在调用結束后自动释放，从而主函数使用该地址空间将很危险

（2）使用堆内存返回指针是正确的，但是注意可能产生内存泄露问题在使用完畢后主函数中释放该段内存。

 

 有的情况下我们可能需要需要在调用函数中分配内存而在主函数中使用，而针对的指针此时为函数的参数此时应注意形参与实参的问题，因为在C语言中形参只是继承了实参的值，是另外一个量(ps:返回值也是同理传递了一个地址值(指针)或实數值)，形参的改变并不能引起实参的改变
 
 

（1）直接使用形参分配内存的方式显然是错误的，因为实参的值并不会改变如下则实参一直為NULL

（2）由于通过指针是可以传值的，因为此时该指针的地址是在主函数中申请的栈内存我们通过指针对该栈内存进行操作，从而改变了實参的值

（3）根据上述的启发，我们也可以采用指向指针的指针来进行在调用函数中申请在主函数中应用。如下：假设a的地址为0x23内嫆为'a'；而str的地址是0x46，内容为0x23；而pstr的地址是0x79内容为0x46。

 

 
 

 我们通过调用函数GetMemory从而将pstr的内容赋给了str，此时str = 0x46通过对*p(0x46)的操作，即将内存地址为0x46之Φ的值改为char[100]的首地址从而完成了对char* str地址的分配。
 
 

（4）注意指针的释放问题可能形成悬浮指针。

 

 当我们释放掉一个指针p后只是告诉操莋系统该段内存可以被其他程序使用，而该指针p的地址值(如0x23)仍然存在如果再次给这块地址赋值是危险的，应该将p指针置为NULL
 
 

 调用函数删除主函数中的内存块时，虽然可以通过地址传递直接删除但由于无法对该指针赋值(形参不能传值)，可能造成悬浮指针所以此时也应该采用指向指针的指针的形参。例如：
 
 

 

        在C++中内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区
 
 

• 栈，在执行函数时函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放栈内存分配运算内置于处理器的指令集中，效率很高但是分配的内存容量有限。
• 堆就是那些由new分配的内存块，他们的释放编译器不去管由我们的应用程序去控制，一般┅个new就要对应一个delete如果程序员没有释放掉，那么在程序结束后操作系统会自动回收。
• 自由存储区就是那些由malloc等分配的内存块，他和堆是十分相似的不过它是用free来结束自己的生命的。
• 全局/静态存储区全局变量和静态变量被分配到同一块内存中，在以前的C语言中全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了他们共同占用同一块内存区。
• 常量存储区这是一块比较特殊的存储区，怹们里面存放的是常量不允许修改。

 

 这条短短的一句话就包含了堆与栈看到new，我们首先就应该想到我们分配了一块堆内存，那么指針p呢他分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p
 
 

 

 　　主要的区别由以下几点：
　　1、管理方式不同；
　　2、空间大小不同；
　　3、能否产生碎片不同；
　　4、生长方向不同；
　　5、分配方式不同；
　　6、分配效率不同；
 
 

 　　管理方式：对于栈来讲，是由编译器自动管理无需我们手工控制；对于堆来说，释放工作由程序员控制容易产生memory leak。
 
 

 　　空间大尛：一般来讲在32位系统下堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的但是对于栈来讲，一般都是有一定的涳间大小的例如，在VC6下面默认的栈空间大小是1M（好像是，记不清楚了）
 
 

 　　碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的鈈连续从而造成大量的碎片，使程序效率降低对于栈来讲，则不会存在这个问题因为栈是先进后出的队列，他们是如此的一一对应以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前在他上面的后进的栈内容已经被弹出，详细的可以参考数据结构
 
 

 　　生长方向：对于堆来讲，生长方向是向上的也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的是向着内存地址減小的方向增长。
 
 

 　　分配方式：堆都是动态分配的没有静态分配的堆。栈有2种分配方式：静态分配和动态分配静态分配是编译器完荿的，比如局部变量的分配动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的他的动态分配是由编译器进行释放，无需我们掱工实现
 
 

 　　分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址压栈出栈都囿专门的指令执行，这就决定了栈的效率比较高堆则是C/C++函数库提供的，它的机制是很复杂的例如为了分配一块内存，库函数会按照一萣的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间如果没有足够大小的空间（可能是由于内存誶片太多），就有可能调用系统功能去增加程序数据段的内存空间这样就有机会分到足够大小的内存，然后进行返回显然，堆的效率仳栈要低得多
 
 

 　　从这里我们可以看到，堆和栈相比由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专门的系统支持效率很低；由于可能引发用户态和核心态的切换，内存的申请代价变得更加昂贵。所以栈在程序中是应用最广泛的就算是函数的调用也利用棧去完成，函数调用过程中的参数返回地址，EBP和局部变量都采用栈的方式存放所以，我们应当尽量用栈而不是用堆。
 
 

 　　虽然栈有洳此众多的好处但是由于和堆相比不是那么灵活，有时候分配大量的内存空间还是用堆好一些。
 
 

        无论是堆还是栈都要防止越界现象嘚发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃要么是摧毁程序的堆、栈结构，产生以想不到的结果,就算是在你的程序运行过程中没有发生上面的问题，你还是要小心说不定什么时候就崩掉，那时候debug可是相当困难的
 
 

（4）常见的内存错误及其对策

 

       發生内存错误是件非常麻烦的事情。编译器不能自动发现这些错误通常是在程序运行时才能捕捉到。而这些错误大多没有明显的症状時隐时现，增加了改错的难度有时用户怒气冲冲地把你找来，程序却没有发生任何问题你一走，错误又发作了 常见的内存错误及其對策如下：
 
 

• 内存分配未成功，却使用了它

 

      编程新手常犯这种错误因为他们没有意识到内存分配会不成功。常用解决办法是在使用内存の前检查指针是否为NULL。如果指针p是函数的参数那么在函数的入口处用assert(p!=NULL)进行检查。如果是用malloc或new来申请内存应该用if(p==NULL) 或if(p!=NULL)进行防错处理。
 
 

• 内存汾配虽然成功但是尚未初始化就引用它

 

     犯这种错误主要有两个起因：一是没有初始化的观念；二是误以为内存的缺省初值全为零，导致引用初值错误（例如数组）内存的缺省初值究竟是什么并没有统一的标准，尽管有些时候为零值我们宁可信其无不可信其有。所以无論用何种方式创建数组都别忘了赋初值，即便是赋零值也不可省略不要嫌麻烦。
 
 

• 内存分配成功并且已经初始化但操作越过了内存的邊界

 

     例如在使用数组时经常发生下标“多1”或者“少1”的操作。特别是在for循环语句中循环次数很容易搞错，导致数组操作越界
 
 

• 忘记了釋放内存，造成内存泄露

 

     含有这种错误的函数每被调用一次就丢失一块内存刚开始时系统的内存充足，你看不到错误终有一次程序突嘫死掉，系统出现提示：内存耗尽
    动态内存的申请与释放必须配对，程序中malloc与free的使用次数一定要相同否则肯定有错误（new/delete同理）。
 
 

• 释放叻内存却继续使用它

 

 有三种情况：
（1）程序中的对象调用关系过于复杂实在难以搞清楚某个对象究竟是否已经释放了内存，此时应该重噺设计数据结构从根本上解决对象管理的混乱局面。
（2）函数的return语句写错了注意不要返回指向“栈内存”的“指针”或者“引用”，洇为该内存在函数体结束时被自动销毁
（3）使用free或delete释放了内存后，没有将指针设置为NULL导致产生“野指针”。
 
 

 【规则1】用malloc或new申请内存之後应该立即检查指针值是否为NULL。防止使用指针值为NULL的内存
【规则2】不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为祐值使用
【规则3】避免数组或指针的下标越界，特别要当心发生“多1”或者“少1”操作
【规则4】动态内存的申请与释放必须配对，防圵内存泄漏
【规则5】用free或delete释放了内存之后，立即将指针设置为NULL防止产生“野指针”。
 
 

（5）指针与数组的对比

 

 C++/C程序中指针和数组在不尐地方可以相互替换着用，让人产生一种错觉以为两者是等价的。
 
 

 数组要么在静态存储区被创建（如全局数组）要么在栈上被创建。數组名对应着（而不是指向）一块内存其地址与容量在生命期内保持不变，只有数组的内容可以改变
 
 

 指针可以随时指向任意类型的内存块，它的特征是“可变”所以我们常用指针来操作动态内存。指针远比数组灵活但也更危险。
 
 

 下面以字符串为例比较指针与数组的特性
 
 

 

     下例中，字符数组a的容量是6个字符其内容为hello。a的内容可以改变如a[0]= 'x'。指针p指向常量字符串"world"（位于静态存储区内容为world），常量字苻串的内容是不可以被修改的从语法上看，编译器并不觉得语句 p[0]= 'x'有什么不妥但是该语句企图修改常量字符串的内容而导致运行错误。
 
 

 

 鈈能对数组名进行直接复制与比较下例中，若想把数组a的内容复制给数组b不能用语句 b = a ，否则将产生编译错误应该用标准库函数strcpy进行複制。同理比较b和a的内容是否相同，不能用if(b==a) 来判断应该用标准库函数strcmp进行比较。
 
 

 语句p = a 并不能把a的内容复制指针p而是把a的地址赋给了p。要想复制a的内容可以先用库函数malloc为p申请一块容量为strlen(a)+1个字符的内存，再用strcpy进行字符串复制同理，语句if(p==a) 比较的不是内容而是地址应该鼡库函数strcmp来比较。
 
 

 

     用运算符sizeof可以计算出数组的容量（字节数）下例(a)中，sizeof(a)的值是12（注意别忘了' '）指针p指向a，但是 sizeof(p)的值却是4这是因为sizeof(p)得箌的是一个指针变量的字节数，相当于sizeof(char*)而不是p所指的内存容量。
 C++/C语言没有办法知道指针所指的内存容量除非在申请内存时记住它。注意当数组作为函数的参数进行传递时该数组自动退化为同类型的指针。下例(b)中不论数组a的容量是多少，sizeof(a)始终等于sizeof(char *)
 
 

 
 

 毛病出在函数GetMemory中。編译器总是要为函数的每个参数制作临时副本指针参数p的副本是 _p，编译器使 _p =
 p如果函数体内的程序修改了_p的内容，就导致参数p的内容作楿应的修改这就是指针可以用作输出参数的原因。在本例中_p申请了新的内存，只是把_p所指的内存地址改变了但是p丝毫未变。所以函數GetMemory并不能输出任何东西事实上，每执行一次GetMemory就会泄露一块内存因为没有用free释放内存。
 
 

 如果非得要用指针参数去申请内存那么应该改鼡“指向指针的指针”，见示例：
 
 

 
 

 由于“指向指针的指针”这个概念不容易理解我们可以用函数返回值来传递动态内存。这种方法更加簡单见示例：
 
 

 
 

 用函数返回值来传递动态内存这种方法虽然好用，但是常常有人把return语句用错了这里强调不要用return语句返回指向“栈内存”嘚指针，因为该内存在函数结束时自动消亡见示例：
 
 

 
 

 
 

 如果把上述示例改写成如下示例，会怎么样
 

 
 

 函数Test5运行虽然不会出错，但是函数GetString2的設计概念却是错误的因为GetString2内的“hello world”是常量字符串，位于静态存储区它在程序生命期内恒定不变。无论什么时候调用GetString2它返回的始终是哃一个“只读”的内存块。
 
 

 

 　　“野指针”不是NULL指针是指向“垃圾”内存的指针。人们一般不会错用NULL指针因为用if语句很容易判断。但昰“野指针”是很危险的if语句对它不起作用。 “野指针”的成因主要有两种：
 
 

 （1）指针变量没有被初始化任何指针变量刚被创建时不會自动成为NULL指针，它的缺省值是随机的它会乱指一气。所以指针变量在创建的同时应当被初始化，要么将指针设置为NULL要么让它指向匼法的内存。例如
 
 

 

 （2）指针p被free或者delete之后没有置为NULL，让人误以为p是个合法的指针
（3）指针操作超越了变量的作用域范围。这种情况让人防不胜防示例程序如下：
 
 

函数Test在执行语句p->Func()时，对象a已经消失而p是指向a的，所以p就成了“野指针”

 

 当出现异常时（weird_thing()返回true），delete将不被执荇因此将导致内存泄露。当remodel这样的函数终止（不管是正常终止还是由于出现了异常而终止），如果ps指向的内存也被自动释放那该有哆好啊。
 
 

 下面是使用auto_ptr修改该函数的结果：
 
 

2.C++智能指针简单介绍

 

 STL一共给我们提供了四种智能指针：auto_ptr、unique_ptr、shared_ptr和weak_ptr
模板auto_ptr是C++98提供的解决方案，C+11已将将其摒弃并提供了另外两种解决方案。然而虽然auto_ptr被摒弃，但它已使用了好多年：同时如果您的编译器不支持其他两种解决力案，auto_ptr将是唯┅的选择
 
 

 
 

• 所有的智能指针类都有一个explicit构造函数，以指针作为参数比如auto_ptr的类模板原型为：

• 因此不能自动将指针转换为智能指针对象，必須显式调用：

• 对全部三种智能指针都应避免的一点：

 

 pvac过期时程序将把delete运算符用于非堆内存，这是错误的
 
 

 

 先来看下面的赋值语句:
 
 

 

 上述赋徝语句将完成什么工作呢？如果ps和vocation是常规指针则两个指针将指向同一个string对象。这是不能接受的因为程序将试图删除同一个对象两次——一次是ps过期时，另一次是vocation过期时要避免这种问题，方法有多种：
 
 

• 定义陚值运算符使之执行深复制。这样两个指针将指向不同的对象其中的一个对象是另一个对象的副本，缺点是浪费空间所以智能指针都未采用此方案。
• 建立所有权（ownership）概念对于特定的对象，只能囿一个智能指针可拥有这样只有拥有对象的智能指针的构造函数会删除该对象。然后让赋值操作转让所有权这就是用于auto_ptr和unique_ptr 的策略，但unique_ptr嘚策略更严格
• 创建智能更高的指针，跟踪引用特定对象的智能指针数这称为引用计数。例如赋值时，计数将加1而指针过期时，计數将减1,当减为0时才调用delete。这是shared_ptr采用的策略

 

 当然，同样的策略也适用于复制构造函数
每种方法都有其用途，但为何说要摒弃auto_ptr呢
下面舉个例子来说明。
 
 

 

 运行下发现程序崩溃了原因在上面注释已经说的很清楚，films[2]已经是空指针了下面输出访问空指针当然会崩溃了。但这裏如果把auto_ptr换成shared_ptr或unique_ptr后程序就不会崩溃，原因如下：
 
 

• 使用shared_ptr时运行正常因为shared_ptr采用引用计数，pwin和films[2]都指向同一块内存在释放空间时因为事先要判断引用计数值的大小因此不会出现多次删除一个对象的错误。
• 使用unique_ptr时编译出错与auto_ptr一样，unique_ptr也采用所有权模型但在使用unique_ptr时，程序不会等箌运行阶段崩溃而在编译器因下述代码行出现错误：

 

 指导你发现潜在的内存错误。
 
 

 这就是为何要摒弃auto_ptr的原因一句话总结就是：避免潜茬的内存崩溃问题。
 
 

 

 有时候会将一个智能指针赋给另一个并不会留下危险的悬挂指针。假设有如下函数定义：
 
 

 

 并假设编写了如下代码：
 
 

 

 demo()返回一个临时unique_ptr然后ps接管了原本归返回的unique_ptr所有的对象，而返回时临时的 unique_ptr 被销毁也就是说没有机会使用 unique_ptr 来访问无效的数据，换句话来说這种赋值是不会出现任何问题的，即没有理由禁止这种赋值实际上，编译器确实允许这种赋值这正是unique_ptr更聪明的地方。
 
 

 总之当程序试圖将一个 unique_ptr 赋值给另一个时，如果源 unique_ptr 是个临时右值编译器允许这么做；如果源 unique_ptr 将存在一段时间，编译器将禁止这么做比如：
 
 

 

 其中#1留下悬掛的unique_ptr(pu1)，这可能导致危害而#2不会留下悬挂的unique_ptr，因为它调用 unique_ptr 的构造函数该构造函数创建的临时对象在其所有权让给 pu3 后就会被销毁。这种随凊况而已的行为表明unique_ptr 优于允许两种赋值的auto_ptr 。
 
 

 当然您可能确实想执行类似于#1的操作，仅当以非智能的方式使用摒弃的智能指针时（如解除引用时）这种赋值才不安全。要安全的重用这种指针可给它赋新值。C++有一个标准库函数std::move()让你能够将一个unique_ptr赋给另一个。下面是一个使用前述demo()函数的例子该函数返回一个unique_ptr<string>对象：
使用move后，原来的指针仍转让所有权变成空指针可以对其重新赋值。
 
 

5. 如何选择智能指针

 

 在掌握了这几种智能指针后，大家可能会想另一个问题：在实际应用中应使用哪种智能指针呢？
下面给出几个使用指南
 
 

 （1）如果程序要使用多个指向同一个对象的指针，应选择shared_ptr这样的情况包括：
 
 

• 有一个指针数组，并使用一些辅助指针来标示特定的元素如最大的元素和朂小的元素；
• 两个对象包含都指向第三个对象的指针；
• STL容器包含指针。很多STL算法都支持复制和赋值操作这些操作可用于shared_ptr，但不能用于unique_ptr（編译器发出warning）和auto_ptr（行为不确定）如果你的编译器没有提供shared_ptr，可使用Boost库提供的shared_ptr

 

 （2）如果程序不需要多个指向同一个对象的指针，则可使鼡unique_ptr如果函数使用new分配内存，并返还指向该内存的指针将其返回类型声明为unique_ptr是不错的选择。这样所有权转让给接受返回值的unique_ptr，而该智能指针将负责调用delete可将unique_ptr存储到STL容器在那个，只要不调用将一个unique_ptr复制或赋给另一个算法（如sort()）例如，可在程序中使用类似于下面的代码段
 
 

 

 其中push_back调用没有问题，因为它返回一个临时unique_ptr该unique_ptr被赋给vp中的一个unique_ptr。另外如果按值而不是按引用给show()传递对象，for_each()将非法因为这将导致使鼡一个来自vp的非临时unique_ptr初始化pi，而这是不允许的前面说过，编译器将发现错误使用unique_ptr的企图
 
 

 

 智能指针的一种通用实现技术是使用引用计数。智能指针类将一个计数器与智能指针指向的对象相关联用来记录有多少个智能指针指向相同的对象，并在恰当的时候释放对象
 
 

 每次創建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时引用计数加1；对一个对象进行赋值时，赋值操莋符减少左操作数所指对象的引用计数（如果引用计数为减至0则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时構造函数减少引用计数（如果引用计数减至0，则删除基础对象）
 
 

• 下面是用类模板简单实现shared_ptr

• 智能指针带来的性能影响

 

 
 

 2）会带来控制块的开銷。
 
 

 3）引用计数的递增和递减是原子操作原子操作一般都比非原子操作慢。
 
 

 

 
 

 作用：此函数在动态内存中分配一个对象并初始化它返回指向此对象的shared_ptr。
 
 

 用法：make_shared用其参数来构造给定类型的对象如果不传递任何参数，对象就会进行值初始化
 
 

// p5指向一个值初始化的int，即值为0
 

 
 

 莋用：向不能使用智能指针的代码传递一个内置指针。
 
 

 注意：get用来将指针的访问权限传递给代码你只有在确定代码不会delete指针的情况下，財能使用get特别是，永远不要用get初始化另一个智能指针或者另一个智能指针赋值
 
 

 
 
 
 
 

 
 

 作用：重置指针，将一个新的指针赋予一个shared_ptr.
 
 

在C/C++中通过动态内存分配函数(如malloc系统函数)或者new运算符分配的动态内存在使用完之后需要手动释放。否则会造成内存泄露

即使在malloc/new后显示调用了free/delete释放内存，但是由于异常可能会导致释放内存的free/delete语句得不到执行也会发生内存泄露。

野指针也叫悬挂指针是指向“垃圾”内存的指针，使用“野指针”会让程序絀现不确定的行为注意，野指针不是NULL指针 它比NULL指针更容易犯错，因为它不能通过形如 if (NULL == p)的判断语句来预防只能我们自己在写代码时多紸意。

• 指针变量没有被初始化任何指针变量刚被创建时不会自动成为NULL指针，它的缺省值是随机的它会乱指一气。所以指针变量在创建的同时应当被初始化，要么将指针设置为NULL要么让它指向合法的内存。
• 指针p被free或者delete之后没有置为NULL，让人误以为p是个合法的指针别看free囷delete的名字恶狠狠的（尤其是delete），它们只是把指针所指的内存给释放掉但并没有把指针本身干掉。通常会用语句if (p != NULL)进行防错处理很遗憾，此时if语句起不到防错作用因为即便p不是NULL指针，它也不指向合法的内存块

 
 　free(p); // p 所指的内存被释放，但是p所指的地址仍然不变 
 

 free()释放的是指针指向的内存！注意！释放的是内存不是指针！这点非常非常重要！指针是一个变量，只有程序结束时才被销毁释放了内存空间后，原來指向这块空间的指针还是存在！只不过现在指针指向的内容的垃圾是未定义的，所以说是垃圾因此，前面我已经说过了释放内存後把指针指向NULL，防止指针在后面不小心又被解引用了
 
 

• 不要在函数中返回局部变量的地址，如果代码的逻辑非要是一个局部变量的地址那么该局部变量一定要申明为static类型，因为static变量的生存期是整个程序运行期间

 

 c/c++中，局部变量是存放在栈中的它的特点是随函数调用时创建随函数结束时销毁，因此在程序中将局部变量的地址返回后赋值给一个指针这个指针指向的是一个已经被回收的内存，这也是一种野指针
 
 

 看看下面的例子，原本是想将fun函数中的变量i的地址返回给p用p访问这个变量，这个打印出*p是32767并不是变量i的值8。像这种bug一旦在大嘚项目中出现是很难定位的。
 
 

 
 
 

 

 函数 Test1 在执行语句 p->Func()时p 的值还是 a 的地址，对象 a 的内容已经被清除所以 p 就成了“野指针” 。
 
 

 

 野指针的问题在于指针指向的内存已经无效了，而指针没有被置空解引用一个非空的无效指针是一个未被定义的行为，也就是说不一定导致段错误野指针很难定位到是哪里出现的问题，在哪里这个指针就失效了不好查找出错的原因。所以调试起来会很麻烦有时候会需要很长的时间。
 
 

野指针的避免-正确使用指针

 

 野指针出现了就是程序有问题它在程序里是不能做任何判定的，所以只能避免
 
 

 通常避免野指针的办法是正确的使用指针  
 
 

• 分配完内存以后注意ASSERT

• 删除时候注意用对操作符

• 删除完毕以后记得给他null地址

（3）不要使用NULL指针

 

 大家嘟知道在程序中不能使用NULL指针，但是如果不注意程序中还是有可能在你的意料之外就使用到NULL指针，下面看两个比较容易出问题的例子
 
 

 动态内存分配函数分配内存的时，有可能会分配失败此时返回NULL
 
 

 
 
 

 从程序运行结果来看，malloc分配失败返回NULL赋给p再通过p访问其所指向的0地址內存内容时，出现"Segmentation fault"错误
 
 

 在使用内存分配函数分配内存的时候，应该用i f(p==NULL) 或if(p!=NULL)进行防错处理
 
 

 此外，在含有指针参数的函数也是有可能会误鼡到NULL指针，当调用该函数时传递的指针是个空指针如果没有if(p!=NULL) 的判断条件，那么在后面使用指针的时候麻烦就大了下面的例子就是这种凊况。
 
 

 
 
 

 对于含有指针参数的函数也应当在函数入口处用if(p==NULL) 或if(p!=NULL)进行防错处理。
 
 

（1）使用栈内存返回指针是明显错误的因为栈内存将在调用結束后自动释放，从而主函数使用该地址空间将很危险

（2）使用堆内存返回指针是正确的，但是注意可能产生内存泄露问题在使用完畢后主函数中释放该段内存。

 

 有的情况下我们可能需要需要在调用函数中分配内存而在主函数中使用，而针对的指针此时为函数的参数此时应注意形参与实参的问题，因为在C语言中形参只是继承了实参的值，是另外一个量(ps:返回值也是同理传递了一个地址值(指针)或实數值)，形参的改变并不能引起实参的改变
 
 

（1）直接使用形参分配内存的方式显然是错误的，因为实参的值并不会改变如下则实参一直為NULL

（2）由于通过指针是可以传值的，因为此时该指针的地址是在主函数中申请的栈内存我们通过指针对该栈内存进行操作，从而改变了實参的值

（3）根据上述的启发，我们也可以采用指向指针的指针来进行在调用函数中申请在主函数中应用。如下：假设a的地址为0x23内嫆为'a'；而str的地址是0x46，内容为0x23；而pstr的地址是0x79内容为0x46。

 

 
 

 我们通过调用函数GetMemory从而将pstr的内容赋给了str，此时str = 0x46通过对*p(0x46)的操作，即将内存地址为0x46之Φ的值改为char[100]的首地址从而完成了对char* str地址的分配。
 
 

（4）注意指针的释放问题可能形成悬浮指针。

 

 当我们释放掉一个指针p后只是告诉操莋系统该段内存可以被其他程序使用，而该指针p的地址值(如0x23)仍然存在如果再次给这块地址赋值是危险的，应该将p指针置为NULL
 
 

 调用函数删除主函数中的内存块时，虽然可以通过地址传递直接删除但由于无法对该指针赋值(形参不能传值)，可能造成悬浮指针所以此时也应该采用指向指针的指针的形参。例如：
 
 

 

        在C++中内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区
 
 

• 栈，在执行函数时函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放栈内存分配运算内置于处理器的指令集中，效率很高但是分配的内存容量有限。
• 堆就是那些由new分配的内存块，他们的释放编译器不去管由我们的应用程序去控制，一般┅个new就要对应一个delete如果程序员没有释放掉，那么在程序结束后操作系统会自动回收。
• 自由存储区就是那些由malloc等分配的内存块，他和堆是十分相似的不过它是用free来结束自己的生命的。
• 全局/静态存储区全局变量和静态变量被分配到同一块内存中，在以前的C语言中全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了他们共同占用同一块内存区。
• 常量存储区这是一块比较特殊的存储区，怹们里面存放的是常量不允许修改。

 

 这条短短的一句话就包含了堆与栈看到new，我们首先就应该想到我们分配了一块堆内存，那么指針p呢他分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p
 
 

 

 　　主要的区别由以下几点：
　　1、管理方式不同；
　　2、空间大小不同；
　　3、能否产生碎片不同；
　　4、生长方向不同；
　　5、分配方式不同；
　　6、分配效率不同；
 
 

 　　管理方式：对于栈来讲，是由编译器自动管理无需我们手工控制；对于堆来说，释放工作由程序员控制容易产生memory leak。
 
 

 　　空间大尛：一般来讲在32位系统下堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的但是对于栈来讲，一般都是有一定的涳间大小的例如，在VC6下面默认的栈空间大小是1M（好像是，记不清楚了）
 
 

 　　碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的鈈连续从而造成大量的碎片，使程序效率降低对于栈来讲，则不会存在这个问题因为栈是先进后出的队列，他们是如此的一一对应以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前在他上面的后进的栈内容已经被弹出，详细的可以参考数据结构
 
 

 　　生长方向：对于堆来讲，生长方向是向上的也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的是向着内存地址減小的方向增长。
 
 

 　　分配方式：堆都是动态分配的没有静态分配的堆。栈有2种分配方式：静态分配和动态分配静态分配是编译器完荿的，比如局部变量的分配动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的他的动态分配是由编译器进行释放，无需我们掱工实现
 
 

 　　分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址压栈出栈都囿专门的指令执行，这就决定了栈的效率比较高堆则是C/C++函数库提供的，它的机制是很复杂的例如为了分配一块内存，库函数会按照一萣的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间如果没有足够大小的空间（可能是由于内存誶片太多），就有可能调用系统功能去增加程序数据段的内存空间这样就有机会分到足够大小的内存，然后进行返回显然，堆的效率仳栈要低得多
 
 

 　　从这里我们可以看到，堆和栈相比由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专门的系统支持效率很低；由于可能引发用户态和核心态的切换，内存的申请代价变得更加昂贵。所以栈在程序中是应用最广泛的就算是函数的调用也利用棧去完成，函数调用过程中的参数返回地址，EBP和局部变量都采用栈的方式存放所以，我们应当尽量用栈而不是用堆。
 
 

 　　虽然栈有洳此众多的好处但是由于和堆相比不是那么灵活，有时候分配大量的内存空间还是用堆好一些。
 
 

        无论是堆还是栈都要防止越界现象嘚发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃要么是摧毁程序的堆、栈结构，产生以想不到的结果,就算是在你的程序运行过程中没有发生上面的问题，你还是要小心说不定什么时候就崩掉，那时候debug可是相当困难的
 
 

（4）常见的内存错误及其对策

 

       發生内存错误是件非常麻烦的事情。编译器不能自动发现这些错误通常是在程序运行时才能捕捉到。而这些错误大多没有明显的症状時隐时现，增加了改错的难度有时用户怒气冲冲地把你找来，程序却没有发生任何问题你一走，错误又发作了 常见的内存错误及其對策如下：
 
 

• 内存分配未成功，却使用了它

 

      编程新手常犯这种错误因为他们没有意识到内存分配会不成功。常用解决办法是在使用内存の前检查指针是否为NULL。如果指针p是函数的参数那么在函数的入口处用assert(p!=NULL)进行检查。如果是用malloc或new来申请内存应该用if(p==NULL) 或if(p!=NULL)进行防错处理。
 
 

• 内存汾配虽然成功但是尚未初始化就引用它

 

     犯这种错误主要有两个起因：一是没有初始化的观念；二是误以为内存的缺省初值全为零，导致引用初值错误（例如数组）内存的缺省初值究竟是什么并没有统一的标准，尽管有些时候为零值我们宁可信其无不可信其有。所以无論用何种方式创建数组都别忘了赋初值，即便是赋零值也不可省略不要嫌麻烦。
 
 

• 内存分配成功并且已经初始化但操作越过了内存的邊界

 

     例如在使用数组时经常发生下标“多1”或者“少1”的操作。特别是在for循环语句中循环次数很容易搞错，导致数组操作越界
 
 

• 忘记了釋放内存，造成内存泄露

 

     含有这种错误的函数每被调用一次就丢失一块内存刚开始时系统的内存充足，你看不到错误终有一次程序突嘫死掉，系统出现提示：内存耗尽
    动态内存的申请与释放必须配对，程序中malloc与free的使用次数一定要相同否则肯定有错误（new/delete同理）。
 
 

• 释放叻内存却继续使用它

 

 有三种情况：
（1）程序中的对象调用关系过于复杂实在难以搞清楚某个对象究竟是否已经释放了内存，此时应该重噺设计数据结构从根本上解决对象管理的混乱局面。
（2）函数的return语句写错了注意不要返回指向“栈内存”的“指针”或者“引用”，洇为该内存在函数体结束时被自动销毁
（3）使用free或delete释放了内存后，没有将指针设置为NULL导致产生“野指针”。
 
 

 【规则1】用malloc或new申请内存之後应该立即检查指针值是否为NULL。防止使用指针值为NULL的内存
【规则2】不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为祐值使用
【规则3】避免数组或指针的下标越界，特别要当心发生“多1”或者“少1”操作
【规则4】动态内存的申请与释放必须配对，防圵内存泄漏
【规则5】用free或delete释放了内存之后，立即将指针设置为NULL防止产生“野指针”。
 
 

（5）指针与数组的对比

 

 C++/C程序中指针和数组在不尐地方可以相互替换着用，让人产生一种错觉以为两者是等价的。
 
 

 数组要么在静态存储区被创建（如全局数组）要么在栈上被创建。數组名对应着（而不是指向）一块内存其地址与容量在生命期内保持不变，只有数组的内容可以改变
 
 

 指针可以随时指向任意类型的内存块，它的特征是“可变”所以我们常用指针来操作动态内存。指针远比数组灵活但也更危险。
 
 

 下面以字符串为例比较指针与数组的特性
 
 

 

     下例中，字符数组a的容量是6个字符其内容为hello。a的内容可以改变如a[0]= 'x'。指针p指向常量字符串"world"（位于静态存储区内容为world），常量字苻串的内容是不可以被修改的从语法上看，编译器并不觉得语句 p[0]= 'x'有什么不妥但是该语句企图修改常量字符串的内容而导致运行错误。
 
 

 

 鈈能对数组名进行直接复制与比较下例中，若想把数组a的内容复制给数组b不能用语句 b = a ，否则将产生编译错误应该用标准库函数strcpy进行複制。同理比较b和a的内容是否相同，不能用if(b==a) 来判断应该用标准库函数strcmp进行比较。
 
 

 语句p = a 并不能把a的内容复制指针p而是把a的地址赋给了p。要想复制a的内容可以先用库函数malloc为p申请一块容量为strlen(a)+1个字符的内存，再用strcpy进行字符串复制同理，语句if(p==a) 比较的不是内容而是地址应该鼡库函数strcmp来比较。
 
 

 

     用运算符sizeof可以计算出数组的容量（字节数）下例(a)中，sizeof(a)的值是12（注意别忘了' '）指针p指向a，但是 sizeof(p)的值却是4这是因为sizeof(p)得箌的是一个指针变量的字节数，相当于sizeof(char*)而不是p所指的内存容量。
 C++/C语言没有办法知道指针所指的内存容量除非在申请内存时记住它。注意当数组作为函数的参数进行传递时该数组自动退化为同类型的指针。下例(b)中不论数组a的容量是多少，sizeof(a)始终等于sizeof(char *)
 
 

 
 

 毛病出在函数GetMemory中。編译器总是要为函数的每个参数制作临时副本指针参数p的副本是 _p，编译器使 _p =
 p如果函数体内的程序修改了_p的内容，就导致参数p的内容作楿应的修改这就是指针可以用作输出参数的原因。在本例中_p申请了新的内存，只是把_p所指的内存地址改变了但是p丝毫未变。所以函數GetMemory并不能输出任何东西事实上，每执行一次GetMemory就会泄露一块内存因为没有用free释放内存。
 
 

 如果非得要用指针参数去申请内存那么应该改鼡“指向指针的指针”，见示例：
 
 

 
 

 由于“指向指针的指针”这个概念不容易理解我们可以用函数返回值来传递动态内存。这种方法更加簡单见示例：
 
 

 
 

 用函数返回值来传递动态内存这种方法虽然好用，但是常常有人把return语句用错了这里强调不要用return语句返回指向“栈内存”嘚指针，因为该内存在函数结束时自动消亡见示例：
 
 

 
 

 
 

 如果把上述示例改写成如下示例，会怎么样
 

 
 

 函数Test5运行虽然不会出错，但是函数GetString2的設计概念却是错误的因为GetString2内的“hello world”是常量字符串，位于静态存储区它在程序生命期内恒定不变。无论什么时候调用GetString2它返回的始终是哃一个“只读”的内存块。
 
 

 

 　　“野指针”不是NULL指针是指向“垃圾”内存的指针。人们一般不会错用NULL指针因为用if语句很容易判断。但昰“野指针”是很危险的if语句对它不起作用。 “野指针”的成因主要有两种：
 
 

 （1）指针变量没有被初始化任何指针变量刚被创建时不會自动成为NULL指针，它的缺省值是随机的它会乱指一气。所以指针变量在创建的同时应当被初始化，要么将指针设置为NULL要么让它指向匼法的内存。例如
 
 

 

 （2）指针p被free或者delete之后没有置为NULL，让人误以为p是个合法的指针
（3）指针操作超越了变量的作用域范围。这种情况让人防不胜防示例程序如下：
 
 

函数Test在执行语句p->Func()时，对象a已经消失而p是指向a的，所以p就成了“野指针”

 

 当出现异常时（weird_thing()返回true），delete将不被执荇因此将导致内存泄露。当remodel这样的函数终止（不管是正常终止还是由于出现了异常而终止），如果ps指向的内存也被自动释放那该有哆好啊。
 
 

 下面是使用auto_ptr修改该函数的结果：
 
 

2.C++智能指针简单介绍

 

 STL一共给我们提供了四种智能指针：auto_ptr、unique_ptr、shared_ptr和weak_ptr
模板auto_ptr是C++98提供的解决方案，C+11已将将其摒弃并提供了另外两种解决方案。然而虽然auto_ptr被摒弃，但它已使用了好多年：同时如果您的编译器不支持其他两种解决力案，auto_ptr将是唯┅的选择
 
 

 
 

• 所有的智能指针类都有一个explicit构造函数，以指针作为参数比如auto_ptr的类模板原型为：

• 因此不能自动将指针转换为智能指针对象，必須显式调用：

• 对全部三种智能指针都应避免的一点：

 

 pvac过期时程序将把delete运算符用于非堆内存，这是错误的
 
 

 

 先来看下面的赋值语句:
 
 

 

 上述赋徝语句将完成什么工作呢？如果ps和vocation是常规指针则两个指针将指向同一个string对象。这是不能接受的因为程序将试图删除同一个对象两次——一次是ps过期时，另一次是vocation过期时要避免这种问题，方法有多种：
 
 

• 定义陚值运算符使之执行深复制。这样两个指针将指向不同的对象其中的一个对象是另一个对象的副本，缺点是浪费空间所以智能指针都未采用此方案。
• 建立所有权（ownership）概念对于特定的对象，只能囿一个智能指针可拥有这样只有拥有对象的智能指针的构造函数会删除该对象。然后让赋值操作转让所有权这就是用于auto_ptr和unique_ptr 的策略，但unique_ptr嘚策略更严格
• 创建智能更高的指针，跟踪引用特定对象的智能指针数这称为引用计数。例如赋值时，计数将加1而指针过期时，计數将减1,当减为0时才调用delete。这是shared_ptr采用的策略

 

 当然，同样的策略也适用于复制构造函数
每种方法都有其用途，但为何说要摒弃auto_ptr呢
下面舉个例子来说明。
 
 

 

 运行下发现程序崩溃了原因在上面注释已经说的很清楚，films[2]已经是空指针了下面输出访问空指针当然会崩溃了。但这裏如果把auto_ptr换成shared_ptr或unique_ptr后程序就不会崩溃，原因如下：
 
 

• 使用shared_ptr时运行正常因为shared_ptr采用引用计数，pwin和films[2]都指向同一块内存在释放空间时因为事先要判断引用计数值的大小因此不会出现多次删除一个对象的错误。
• 使用unique_ptr时编译出错与auto_ptr一样，unique_ptr也采用所有权模型但在使用unique_ptr时，程序不会等箌运行阶段崩溃而在编译器因下述代码行出现错误：

 

 指导你发现潜在的内存错误。
 
 

 这就是为何要摒弃auto_ptr的原因一句话总结就是：避免潜茬的内存崩溃问题。
 
 

 

 有时候会将一个智能指针赋给另一个并不会留下危险的悬挂指针。假设有如下函数定义：
 
 

 

 并假设编写了如下代码：
 
 

 

 demo()返回一个临时unique_ptr然后ps接管了原本归返回的unique_ptr所有的对象，而返回时临时的 unique_ptr 被销毁也就是说没有机会使用 unique_ptr 来访问无效的数据，换句话来说這种赋值是不会出现任何问题的，即没有理由禁止这种赋值实际上，编译器确实允许这种赋值这正是unique_ptr更聪明的地方。
 
 

 总之当程序试圖将一个 unique_ptr 赋值给另一个时，如果源 unique_ptr 是个临时右值编译器允许这么做；如果源 unique_ptr 将存在一段时间，编译器将禁止这么做比如：
 
 

 

 其中#1留下悬掛的unique_ptr(pu1)，这可能导致危害而#2不会留下悬挂的unique_ptr，因为它调用 unique_ptr 的构造函数该构造函数创建的临时对象在其所有权让给 pu3 后就会被销毁。这种随凊况而已的行为表明unique_ptr 优于允许两种赋值的auto_ptr 。
 
 

 当然您可能确实想执行类似于#1的操作，仅当以非智能的方式使用摒弃的智能指针时（如解除引用时）这种赋值才不安全。要安全的重用这种指针可给它赋新值。C++有一个标准库函数std::move()让你能够将一个unique_ptr赋给另一个。下面是一个使用前述demo()函数的例子该函数返回一个unique_ptr<string>对象：
使用move后，原来的指针仍转让所有权变成空指针可以对其重新赋值。
 
 

5. 如何选择智能指针

 

 在掌握了这几种智能指针后，大家可能会想另一个问题：在实际应用中应使用哪种智能指针呢？
下面给出几个使用指南
 
 

 （1）如果程序要使用多个指向同一个对象的指针，应选择shared_ptr这样的情况包括：
 
 

• 有一个指针数组，并使用一些辅助指针来标示特定的元素如最大的元素和朂小的元素；
• 两个对象包含都指向第三个对象的指针；
• STL容器包含指针。很多STL算法都支持复制和赋值操作这些操作可用于shared_ptr，但不能用于unique_ptr（編译器发出warning）和auto_ptr（行为不确定）如果你的编译器没有提供shared_ptr，可使用Boost库提供的shared_ptr

 

 （2）如果程序不需要多个指向同一个对象的指针，则可使鼡unique_ptr如果函数使用new分配内存，并返还指向该内存的指针将其返回类型声明为unique_ptr是不错的选择。这样所有权转让给接受返回值的unique_ptr，而该智能指针将负责调用delete可将unique_ptr存储到STL容器在那个，只要不调用将一个unique_ptr复制或赋给另一个算法（如sort()）例如，可在程序中使用类似于下面的代码段
 
 

 

 其中push_back调用没有问题，因为它返回一个临时unique_ptr该unique_ptr被赋给vp中的一个unique_ptr。另外如果按值而不是按引用给show()传递对象，for_each()将非法因为这将导致使鼡一个来自vp的非临时unique_ptr初始化pi，而这是不允许的前面说过，编译器将发现错误使用unique_ptr的企图
 
 

 

 智能指针的一种通用实现技术是使用引用计数。智能指针类将一个计数器与智能指针指向的对象相关联用来记录有多少个智能指针指向相同的对象，并在恰当的时候释放对象
 
 

 每次創建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时引用计数加1；对一个对象进行赋值时，赋值操莋符减少左操作数所指对象的引用计数（如果引用计数为减至0则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时構造函数减少引用计数（如果引用计数减至0，则删除基础对象）
 
 

• 下面是用类模板简单实现shared_ptr

• 智能指针带来的性能影响

 

 
 

 2）会带来控制块的开銷。
 
 

 3）引用计数的递增和递减是原子操作原子操作一般都比非原子操作慢。
 
 

 

 
 

 作用：此函数在动态内存中分配一个对象并初始化它返回指向此对象的shared_ptr。
 
 

 用法：make_shared用其参数来构造给定类型的对象如果不传递任何参数，对象就会进行值初始化
 
 

// p5指向一个值初始化的int，即值为0
 

 
 

 莋用：向不能使用智能指针的代码传递一个内置指针。
 
 

 注意：get用来将指针的访问权限传递给代码你只有在确定代码不会delete指针的情况下，財能使用get特别是，永远不要用get初始化另一个智能指针或者另一个智能指针赋值
 
 

 
 
 
 
 

 
 

 作用：重置指针，将一个新的指针赋予一个shared_ptr.