SMART POINTER(智能指针)

原创 2004年02月03日 13:51:00

智能指针(smart pointer):
智能指针是其实是一个对象A,它带有一个模针成员变量m_p.用该A管理m_p,通过这种管理机制,可以防止由于new而导致的内存泄漏.
智能指针对象在使用时像指针一样.同时也具有一般对象的所有特征.如果要注意以下几点:
1,对象之间的赋值:若有A=B,则在赋值时,
首先要松查是否为自身赋值.如果不是,则释放A对象成员指针的内存空间,
然后要将B中的成员指针赋值于A的成员指针,
接着将B中的成员指针置为空,这样可以避免多个指针同时指向一个内存空间而产生多次析构此内存空间的错误.
所以,重载的赋值函数一般如下:
operator =(Test& source_object); 此处不能为const 对象的引用,这是因为要修改source_object 的成员指针为空.
2,对于copy constroctor也有与operator=类似的情况.只不过不要释放A成员指针的内存空间,.
3,关于member template的问题,它往往用于兼容模板对象之间的相互赋值,copy constroctor.我们可以将它看成是个模板类(一个类).
譬如:auto_ptr<B>,这就是一个类名称
   另:VC7.0中,成员模板的定义和实现必须放在类的定义中.
注:member template不能为static 或virtual
4,智能指针中必须重载的几个运算符: ->    *
这样做的目的就是将对象模仿成指针的行为.
如下:
T* operator ->() 
{return m_p;}

特别注意:
object->m_p;== (object.operator->())->m_p;


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


下面的程序演示smart pointer的基本使用:
#include"iostream"
using namespace std;
template<class T>
class auto_ptr
{
public:
 auto_ptr( T *p=0)
 {
  m_p=p;
 }

   //由auto_ptr<T> 来复制构造该auto_ptr<T>对象.
 auto_ptr(auto_ptr<T>& source_object)
 {
    m_p=(T*)( source_object.get());

 source_object.m_p=0;  //

 }
 //由auto_ptr<M>来构造该auto_ptr<T>对象. 
 template<class M>
  auto_ptr(auto_ptr<M>  &source_object)  //此处的对象为非const 对象的引用.
 {
       m_p=(T*)( source_object.get());
 source_object.m_p=0;  //
 }

 //析构....
 ~auto_ptr()
 {
  if (m_p!=0)
   Release();
 }

 //由auto_ptr<T>赋值于auto_ptr<T>对象.
    auto_ptr<T>& operator=(auto_ptr<T> &source_object)
 {
  Release();
        m_p=(T*)(source_object.get());
  return *this;
 }

    //由auto_ptr<M>赋值于auto_ptr<T>对象.
 template<class M>
 auto_ptr<T>& operator=(auto_ptr<M> &source_object)
 {
  Release();
        m_p=(T*)(source_object.get());
  return *this;
 }
 
    //delete m_p;
 void Release()
 {
  if (m_p!=0)
   delete m_p;
   m_p=0;
 }

 T* get()
 {
  return m_p;
 }
 // from auto_ptr<T> convert to auto_ptr<M>


 //声明:1 由于上面提供从auto_ptr<M>构造auto_ptr<T>的构造函数.所以,在实际上,不必给出下面的隐式类型转换函数.
 //     2 VC不支持这个隐式转换特性.
 template<class M>
  operator auto_ptr<M>()  
  //如果M和T类型不一致时,将无法进行自动的类型转换.如:auto_ptr<int> 与auto_ptr<float>
 {
 
  return auto_ptr<M>(m_p);

  //此处困惑:::
  // return auto_ptr<M>(m_p); 这是more effective C++中的写法,当执行此语句时,会构造出一个新auto_ptr<M>的对象,而this对象的m_p并未释放.这样两个对象的m_p指向共一个变量,???
       //应该这样:
       //temp auto_ptr<M>(get());
 //Release();
 //return temp;
 }

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

 const T* operator->() const
 {
  return m_p;
 }
 //此处注意为T&,这样可以实现左值.
 T& operator *()
 {
  return *m_p;
 }

 const T& operator *() const
 {
  return *m_p;
 }
public:
 T *m_p;
};


class test
{
public:
 test(int data)
 {
  m_data=data;
 }
int& operator->()
{
 return m_data;
}

   operator int()
{
 return m_data;
}

public:
 

 int m_data;
};

 

class A
{
public:
 A(int data)
 {
  m_data=data;
 }
private:
 int m_data;

};

class B:public A
{
public:
 B(int data):A(data*2),m_data(data)
 {
  ;
 }
private:
 int m_data;

};

class C:public A
{
public:
 C(int data):A(data*3),m_data(data)
 {
  ;
 }
private:
 int m_data;


};
void test_member_template(const auto_ptr<A>& source_object) 
//此处一定要加const,因为对象隐式转换后生成的对象为临时对象.临时对象的生存周期将不由程序员决定,其值不能被修改.
{
//source_object.get();
}

void test_member_template2(const auto_ptr<int>& source_object)
//此处一定要加const,因为对象隐式转换后生成的对象为临时对象.临时对象的生存周期将不由程序员决定,其值不能被修改.
{
 ;
}

void main()
{
 auto_ptr<C> object2(new C(3));
 test_member_template(object2);
       //将调用member template constructor 构造出auto_ptr<A> 对象.注意,函数执行后,将导致object2变为为空壳对象.要避免这种隐式的模板对象构造.

 auto_ptr<test> object(new test(15));
 int data=object.operator->()->m_data;
 //等价于:  data=object.operator->()->operator->();
 cout<<data;

       auto_ptr<int> object_int(new int(999));

 auto_ptr<int> object_int_2(new int(333));

 object_int_2=object_int; //operator =

 object_float=object_int; //operator =  by member template

 test_member_template2(object_int);  //copy constructor

       test_member_template2(object_float);//call constructor by member template.
       //注意,函数执行后,将导致object2变为为空壳对象.要避免这种隐式的模板对象构造.
 cout<<*object_float<<endl;;
 auto_ptr<float> object_2=object_float;
       //此处调用 copy constructor
 cout<<*object_2<<endl;

      
}

c++智能指针(smart pointer)详解

Smart Pointer Deal with c++11’s smart pointer facility. brief Smart pointers are class objects t...
  • Dream_going
  • Dream_going
  • 2017年02月17日 14:59
  • 508

【C++】智能指针(Smart Pointer)

本文主要翻译自 http://www.codeproject.com/Articles/541067/Cplusplus-Smart-Pointers1. 传统指针存在的问题传统指针存在诸多的问题,...
  • zone_programming
  • zone_programming
  • 2015年07月22日 11:18
  • 4072

智能指针(smart pointer)

智能指针(smart pointer)是一种抽象的数据类型(abstract data type)。 在程序设计中, 智能指针通常由类模板(class template), 借助模板达到泛型。 通常借...
  • a130737
  • a130737
  • 2015年03月23日 18:46
  • 1368

共享型智能指针的实现share_pointer

智能指针是一个类,它产生的是一个类对象,而不是一个原生的指针对象,但是为了减少类对象与针对对象使用的差异性,所以share_ptr类故意重载了两种常见的指针操作符: *和->。从而share_ptr与...
  • st125475466
  • st125475466
  • 2015年09月08日 19:43
  • 1264

C++中的智能指针(smart pointer)

指针问题是在学习C++,以及运用C++进行软件开发过程中经常碰到的问题。其中之一,就是“悬垂指针”。所谓悬垂指针,就是是指指针指向了一块没有分配给用户使用的内存,结果未定义,往往导致程序错误,而且难以...
  • u010801219
  • u010801219
  • 2013年08月26日 22:23
  • 666

C++中的智能指针(smart pointer)

一、简介 由于 C++ 语言没有自动内存回收机制,程序员每次 new 出来的内存都要手动 delete。程序员忘记 delete,流程太复杂,最终导致没有 delete,异常导致程序过早退出,没有执...
  • ninanangel
  • ninanangel
  • 2014年08月19日 16:58
  • 343

STL中的智能指针(Smart Pointer)及其源码剖析: std::auto_ptr

STL中的智能指针(Smart Pointer)及其源码剖析: std::auto_ptr 本文主要介绍了 auto_ptr的使用及其源码。 auto_ptr是STL中的智能指针家族的成员之一, ...
  • yanglingwell
  • yanglingwell
  • 2017年02月20日 12:22
  • 11050

C++标准库学习笔记(Shared Pointer)-3

声明:这个博文所有内容均来自于C++标准库-自学教程与参考手册(第二版)英文版 上册。如果转载,务必附带本声明,并注明出处。 smart pointer就是智能指针,它能够自动计数引用,...
  • thesby
  • thesby
  • 2015年06月16日 22:59
  • 1037

C++ — 智能指针的简单实现以及循环引用问题

智能指针
  • Dawn_sf
  • Dawn_sf
  • 2017年04月17日 17:14
  • 900

VTK修炼之道80:VTK开发基础_智能指针与引用计数

1.引用计数 VTK经过多年的开发与维护,已经形成了一套稳定的框架和开发规则。因此,了解这些规则和框架是定制VTK类的基础,这其中用到了大量面向对象的设计模式,例如对象工程模式、观察者/命令模式;...
  • shenziheng1
  • shenziheng1
  • 2017年02月10日 23:45
  • 691
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:SMART POINTER(智能指针)
举报原因:
原因补充:

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