智能指针123

转载 2015年11月21日 17:49:01


1.智能指针 smart_ptr
由于 C++ 语言没有自动内存回收机制,程序员每次 new 出来的内存都要手动 delete。程序员忘记 delete,流程太复杂,最终导致没有 delete,异常导致程序过早退出,没有执行 delete 的情况并不罕见。
用智能指针便可以有效缓解这类问题,本文主要讲解参见的智能指针的用法。包括:std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: intrusive_ptr。


2.
对于编译器来说,智能指针实际上是一个栈对象,并非指针类型,在栈对象生命期即将结束时,智能指针通过析构函数释放有它管理的堆内存。


所有智能指针都重载了“operator->”操作符,直接返回对象的引用,用以操作对象。访问智能指针原来的方法则使用“.”操作符。


访问智能指针包含的裸指针则可以用 get() 函数。由于智能指针是一个对象,所以if (my_smart_object)永远为真,要判断智能指针的裸指针是否为空,需要这样判断:if (my_smart_object.get())。


智能指针包含了 reset() 方法,如果不传递参数(或者传递 NULL),则智能指针会释放当前管理的内存。如果传递一个对象,则智能指针会释放当前对象,来管理新传入的对象。




C++智能指针是行为类似于指针的类对象。它使用设计模式中的代理模式,代理了原始“裸”指针的行为,为指针添加了更多更有用的特性。


C++引入异常机制后,智能指针由一种技巧升级为一种非常重要的技术,因为如果没有智能指针,程序员必须保证new对象能在正确的时机delete,四处编写异常捕获代码释放资源,而智能指针则可以在退出作用域时——不管是正常离开或是因异常离开——总调用delete来析构在堆栈上动态分配的对象。


因为C++异常处理的真正功能在于它具有为异常抛掷前构造的所有局部对象(那么智能指针对象也适用)自动调用析构函数的能力(C++异常机制不仅仅在于它能够处理各种不同类型的异常)。所以在异常退出智能指针对象作用域时,总能由C++异常机制调用析构函数释放在堆栈上动态分配的对象。


当然,正常退出对象(智能指针对象也属于此列)作用域也会自动调用析构函数释放在堆栈上动态分配的对象。


由此可知,将“裸”指针包装成智能指针对象可以实现动态分配的内存对象的自动释放。
而且C++智能指针对象可以像原指针那样直接使用运算符,如赋值运算符'=',指针运算符'->',解引用运算符'*'。这点可以从下面的”shared_ptr智能指针--shared_ptr模板类摘要“部分可以印证。




3.std::auto_ptr C++98
所属头文件:#include <memory>
所属命名空间及标识符:using std::shared_ptr;
所属版本:C++98
g++启用版本命令:g++ -std=c++98 -c -o
补充:
如果启用c++11及以上标准,即g++ -std=c++11 -c -o,编译时会有一个警告信息提示
warning:‘auto_ptr’ is deprecated  (‘auto_ptr‘被反对使用)
它部分解决了获取资源自动释放的问题  
release()
reset() 
get()

=(最好不要使用) 
->
原来 std::auto_ptr 的 release() 函数只是让出内存所有权,这显然也不符合 C++ 编程思想。
总结:std::auto_ptr 可用来管理单个对象的对内存,但是,请注意如下几点:
(1)    尽量不要使用“operator=”。如果使用了,请不要再使用先前对象。
(2)    记住 release() 函数不会释放对象,仅仅归还所有权。
(3)    std::auto_ptr 最好不要当成参数传递(读者可以自行写代码确定为什么不能)。
(4)    由于 std::auto_ptr 的“operator=”问题,有其管理的对象不能放入 std::vector 等容器中。
(5)    ……
使用一个 std::auto_ptr 的限制还真多


接着看boost 的智能指针,boost 智能指针可以解决如上问题。
4.boost::scoped_ptr
boost::scoped_ptr 属于 boost 库,定义在 namespace boost 中,包含头文件 #include<boost/smart_ptr.hpp> 便可以使用。boost::scoped_ptr 跟 std::auto_ptr 一样,可以方便的管理单个堆内存对象,特别的是,boost::scoped_ptr 独享所有权,避免了 std::auto_ptr 恼人的几个问题。


void TestScopedPtr() {
boost::scoped_ptr<Simple> my_memory(new Simple(1));
if (my_memory.get()) {
my_memory->PrintSomething();
my_memory.get()->info_extend = "Addition";
my_memory->PrintSomething();
(*my_memory).info_extend += " other";
my_memory->PrintSomething();


my_memory.release();
// 编译 error: scoped_ptr 没有 release 函数,独享所有权
std::auto_ptr<Simple> my_memory2;
my_memory2 = my_memory;     
// 编译 error: scoped_ptr 没有重载 operator=,不会导致所有权转移
}
}
由于 boost::scoped_ptr 独享所有权,当我们真真需要复制智能指针时,需求便满足不了了,如此我们再引入一个智能指针,专门用于处理复制,参数传递的情况,这便是如下的 boost::shared_ptr。


5.boost::shared_ptr智能指针(C++11)


boost::shared_ptr 属于 boost 库,定义在 namespace boost 中,包含头文件 #include<boost/smart_ptr.hpp> 便可以使用。在上面我们看到 boost::scoped_ptr 独享所有权,不允许赋值、拷贝,boost::shared_ptr 是专门用于共享所有权的,由于要共享所有权,其在内部使用了引用计数。boost::shared_ptr 也是用于管理单个堆内存对象的。


void TestSharedPtr(boost::shared_ptr<Simple> memory) {  // 注意:无需使用 reference (或 const reference)
memory->PrintSomething();//直接使用->,无需使用get()返回引用
std::cout << "TestSharedPtr UseCount: " << memory.use_count() << std::endl;
}


void TestSharedPtr2() {
boost::shared_ptr<Simple> my_memory(new Simple(1));
if (my_memory.get()) {
my_memory->PrintSomething();
my_memory.get()->info_extend = "Addition";
my_memory->PrintSomething();
(*my_memory).info_extend += " other";
my_memory->PrintSomething();
}


std::cout << "TestSharedPtr2 UseCount: " << my_memory.use_count() << std::endl;
TestSharedPtr(my_memory);
std::cout << "TestSharedPtr2 UseCount: " << my_memory.use_count() << std::endl;


//my_memory.release();
// 编译 error: 同样,shared_ptr 也没有 release 函数


}




boost::shared_ptr 也可以很方便的使用。并且没有 release() 函数。关键的一点,boost::shared_ptr 内部维护了一个引用计数,由此可以支持复制、参数传递等。boost::shared_ptr 提供了一个函数 use_count() ,此函数返回 boost::shared_ptr 内部的引用计数。查看执行结果,我们可以看到在 TestSharedPtr2 函数中,引用计数为 1,传递参数后(此处进行了一次复制),在函数TestSharedPtr 内部,引用计数为2,在 TestSharedPtr 返回后,引用计数又降低为 1。当我们需要使用一个共享对象的时候,boost::shared_ptr 是再好不过的了。
在此,我们已经看完单个对象的智能指针管理,关于智能指针管理数组,我们接下来讲到。






6.boost::scoped_array 


独享所有权数组


boost::scoped_array 属于 boost 库,定义在 namespace boost 中,包含头文件 #include<boost/smart_ptr.hpp> 便可以使用。


boost::scoped_array 便是用于管理动态数组的。跟 boost::scoped_ptr 一样,也是独享所有权的。


我们还是从代码开始分析:
void TestScopedArray() {
boost::scoped_array<Simple> my_memory(new Simple[2]); // 使用内存数组来初始化
if (my_memory.get()) {
my_memory[0].PrintSomething();
my_memory.get()[0].info_extend = "Addition";
my_memory[0].PrintSomething();
(*my_memory)[0].info_extend += " other";  
// 编译 error,scoped_ptr 没有重载 operator*
my_memory[0].release();  
// 同上,没有 release 函数
boost::scoped_array<Simple> my_memory2;
my_memory2 = my_memory;  
// 编译 error,同上,没有重载 operator=
}
}
boost::scoped_array 的使用跟 boost::scoped_ptr 差不多,不支持复制,并且初始化的时候需要使用动态数组。另外,boost::scoped_array 没有重载“operator*”,其实这并无大碍,一般情况下,我们使用 get() 函数更明确些。
下面肯定应该讲 boost::shared_array 了,一个用引用计数解决复制、参数传递的智能指针类。






7.boost::shared_array




boost::shared_array 属于 boost 库,定义在 namespace boost 中,包含头文件 #include<boost/smart_ptr.hpp> 便可以使用。


由于 boost::scoped_array 独享所有权,显然在很多情况下(参数传递、对象赋值等)不满足需求,由此我们引入 boost::shared_array。跟 boost::shared_ptr 一样,内部使用了引用计数。




我们还是从代码开始分析:


void TestSharedArray(boost::shared_array<Simple> memory) {  
// 注意:无需使用 reference (或 const reference)
std::cout << "TestSharedArray UseCount: " << memory.use_count() << std::endl;
}


void TestSharedArray2() {
boost::shared_array<Simple> my_memory(new Simple[2]);
if (my_memory.get()) {
my_memory[0].PrintSomething();
my_memory.get()[0].info_extend = "Addition 00";
my_memory[0].PrintSomething();
my_memory[1].PrintSomething();
my_memory.get()[1].info_extend = "Addition 11";
my_memory[1].PrintSomething();
//(*my_memory)[0].info_extend += " other";  
// 编译 error,scoped_ptr 没有重载 operator*
}
std::cout << "TestSharedArray2 UseCount: " << my_memory.use_count() << std::endl;
TestSharedArray(my_memory);
std::cout << "TestSharedArray2 UseCount: " << my_memory.use_count() << std::endl;
}


跟 boost::shared_ptr 一样,使用了引用计数,可以复制,通过参数来传递。
 
至此,我们讲过的智能指针有 std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array。


这几个智能指针已经基本够我们使用了,90% 的使用过标准智能指针的代码就这 5 种。可如下还有两种智能指针,它们肯定有用,但有什么用处呢,一起看看吧。






7、boost::weak_ptr
boost::weak_ptr 属于 boost 库,定义在 namespace boost 中,包含头文件 #include<boost/smart_ptr.hpp> 便可以使用。


在讲 boost::weak_ptr 之前,让我们先回顾一下前面讲解的内容。似乎 boost::scoped_ptr、boost::shared_ptr 这两个智能指针就可以解决所有单个对象内存的管理了,这儿还多出一个 boost::weak_ptr,是否还有某些情况我们没纳入考虑呢?


回答:有。
首先 boost::weak_ptr 是专门为 boost::shared_ptr 而准备的。有时候,我们只关心能否使用对象,并不关心内部的引用计数。boost::weak_ptr 是 boost::shared_ptr 的观察者(Observer)对象,观察者意味着 boost::weak_ptr 只对 boost::shared_ptr 进行引用,而不改变其引用计数,当被观察的 boost::shared_ptr 失效后,相应的 boost::weak_ptr 也相应失效。


我们还是从代码开始分析:
    void TestWeakPtr() {
     boost::weak_ptr<Simple> my_memory_weak;
       boost::shared_ptr<Simple> my_memory(new Simple(1));
 
     std::cout << "TestWeakPtr boost::shared_ptr UseCount: " << my_memory.use_count() << std::endl;
       my_memory_weak = my_memory;
     std::cout << "TestWeakPtr boost::shared_ptr UseCount: " << my_memory.use_count() << std::endl;
}
    执行结果为:
Simple: 1
TestWeakPtr boost::shared_ptr UseCount: 1
TestWeakPtr boost::shared_ptr UseCount: 1
~Simple: 1
我们看到,尽管被赋值了,内部的引用计数并没有什么变化,当然,读者也可以试试传递参数等其他情况。
   
现在要说的问题是,boost::weak_ptr 到底有什么作用呢?从上面那个例子看来,似乎没有任何作用,

其实 boost::weak_ptr 主要用在软件架构设计中,可以在基类(此处的基类并非抽象基类,而是指继承于抽象基类的虚基类)中定义一个 boost::weak_ptr,用于指向子类的 boost::shared_ptr,这样基类仅仅观察自己的 boost::weak_ptr 是否为空就知道子类有没对自己赋值了,而不用影响子类 boost::shared_ptr 的引用计数,用以降低复杂度,更好的管理对象。
    
8.boost::intrusive_ptr


boost::intrusive_ptr属于 boost 库,定义在 namespace boost 中,包含头文件 #include<boost/smart_ptr.hpp> 便可以使用。


讲完如上 6 种智能指针后,对于一般程序来说 C++ 堆内存管理就够用了,现在有多了一种 boost::intrusive_ptr,这是一种插入式的智能指针,内部不含有引用计数,需要程序员自己加入引用计数,不然编译不过






如上讲了这么多智能指针,有必要对这些智能指针做个总结:
1、在可以使用 boost 库的场合下,拒绝使用 std::auto_ptr,因为其不仅不符合 C++ 编程思想,而且极容易出错[2]。
2、在确定对象无需共享的情况下,使用 boost::scoped_ptr(当然动态数组使用 boost::scoped_array)。
3、在对象需要共享的情况下,使用 boost::shared_ptr(当然动态数组使用 boost::shared_array)。
4、在需要访问 boost::shared_ptr 对象,而又不想改变其引用计数的情况下,使用 boost::weak_ptr,一般常用于软件框架设计中。
5、最后一点,也是要求最苛刻一点:在你的代码中,不要出现 delete 关键字(或 C 语言的 free 函数),因为可以用智能指针去管理。
 
---------------------------------------
[1]参见《effective C++(3rd)》,条款06 。
[2]关于 boost 库的使用,可本博客另外一篇文章:《在 Windows 中编译 boost1.42.0》。
[3]读者应该看到了,在我所有的名字前,都加了命名空间标识符std::(或boost::),这不是我不想写 using namespace XXX 之类的语句,在大型项目中,有可能会用到 N 个第三方库,如果把命名空间全放出来,命名污染(Naming conflicts)问题很难避免,到时要改回来是极端麻烦的事情。当然,如果你只是写 Demo,可以例外。


http://blog.csdn.net/xt_xiaotian/article/details/5714477
http://blog.csdn.net/acs713/article/details/29175231
http://jingyan.baidu.com/article/9f7e7ec0b785ae6f281554f6.html

智能指针的使用示例

  • 2013年04月16日 14:41
  • 2KB
  • 下载

C++智能指针测试代码

  • 2016年04月15日 14:47
  • 5KB
  • 下载

Qt和Standard&nbsp;C++智能指针比较

一、相关知识总结 C++的智能指针是通过模版类来实现的。其中,模版(template)让它可以匹配任一指针类型,(记住,它默认匹配指针类型);类,将指针模版进行封装,在析构函数中进行delete操作...

智能指针使用

  • 2014年08月27日 16:08
  • 28KB
  • 下载

symbian 智能指针源代码

  • 2008年10月10日 17:08
  • 134KB
  • 下载

boost库在工作(8)引用计数的智能指针shared_ptr之一

在前面已经介绍了三个智能指针,它们都是适合在局部作用域,不进行拷贝的情况下使用,最为合适,如果使用到其它情况,使用的好处跟坏处一样多,这种情况就不宜使用了。在目前多核处理器流行的今天,并发处理已经成为...

智能指针(新版)

  • 2013年06月05日 23:38
  • 11KB
  • 下载

c++智能指针的实现

  • 2015年07月02日 17:50
  • 715KB
  • 下载

C++11 FAQ中文版:共享资源的智能指针——shared_ptr

三13 Year 2011陈 良乔C++11 FAQ 共享资源的智能指针——shared_ptr shared_ptr被用来表示共享的拥有权。也就是说,当两段代码都需要访问一些数据,而它们又都没有独...

Boost智能指针示例源码

  • 2017年11月15日 23:42
  • 51KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:智能指针123
举报原因:
原因补充:

(最多只允许输入30个字)