C++管理指针成员

原创 2015年07月08日 14:48:44

1、C++中一般采用下面三种方法之一管理指针成员:

    (1)指针成员采取常规行为。这样的类具有指针的所有缺陷:具有指针成员且使用默认复制构造函数和赋值操作符,无法避免悬垂指针(两个对象的指针成员指向同一内存,删除了其中一个指针指向的内存时,另一个指针将不再指向有效的内存空间)。

    (2)类可以实现所谓的"智能指针"行为。引入计数类,智能指针类将一个计数器与类的对象相关联。使用计数跟踪该类有多少个对象共享同一指针。当计数为0时,删除对象。

    (3)类采取值行为。采用重载的复制构造函数、赋值操作符和析构函数。

2、指针成员采取常规行为示例:两个指针指向同一块内存,会引起不可预料的后果

  1. #include "stdafx.h"  
  2. #include <string.h>  
  3. #include <iostream.h>  
  4.   
  5. class HasPtr  
  6. {  
  7. public:  
  8.     HasPtr(int *p,int i):ptr(p),val(i){}  
  9.   
  10.     int *get_ptr()const{return ptr;}  
  11.     int get_val()const{return val;}  
  12.   
  13.     void set_ptr(int *p){ptr=p;}  
  14.     void set_val(int i){val=i;}  
  15.   
  16.     int get_ptr_val()const{return *ptr;}  
  17.   
  18.     void set_ptr_val(int val)const{*ptr=val;}  
  19.   
  20. private:  
  21.     int *ptr;  
  22.     int val;  
  23. };  
  24.   
  25. int main(int argc, char* argv[])  
  26. {     
  27.     int *p=new int(10);  
  28.     cout<<p<<endl;  
  29.     HasPtr ptr(p,10);  
  30.     cout<<ptr.get_ptr()<<endl;  
  31.     delete p;  
  32.     cout<<ptr.get_ptr_val()<<endl;  //p和ptr中的指针指向同一对象。删除该对象后,ptr中的指针不再指向有效的对象。  
  33.     return 0;  
  34. }  

3、"智能指针"行为示例:注意构造函数

  1. #include "stdafx.h"  
  2. #include <string.h>  
  3. #include <iostream.h>  
  4.   
  5. class HasPtr;  
  6. //计数类U_Ptr所有成员均为private,将HasPtr设置为计数类的友元类,使其可以访问U_Ptr的成员  
  7. class U_Ptr  
  8. {  
  9.     friend class HasPtr;  
  10.     int *ip;  
  11.     size_t use;  
  12.     U_Ptr(int *p):ip(p),use(1){}  
  13.     ~U_Ptr()  
  14.     {  
  15.         delete ip;  
  16.     }  
  17. };  
  18.   
  19. class HasPtr  
  20. {  
  21. public:  
  22.     HasPtr(int *p,int i):ptr(new U_Ptr(new int(*p))),val(i){} //构造函数,创建新的U_Ptr对象  
  23.   
  24.     HasPtr(const HasPtr &orig):ptr(orig.ptr),val(orig.val){++ptr->use;} //复制构造函数,计数加1  
  25.   
  26.     HasPtr& operator=(const HasPtr &rhs)  //赋值操作符,左操作数计数减1,右操作数计数加1,如果左操作数减至0,则删除左操作数指向的对象  
  27.     {  
  28.         if (this!=&rhs)  
  29.         {  
  30.             ++rhs.ptr->use;  
  31.             if(--ptr->use==0)  
  32.                 delete ptr;  
  33.             ptr=rhs.ptr;  
  34.             val=rhs.val;  
  35.         }  
  36.         return *this;  
  37.     }  
  38.       
  39.     ~HasPtr() //析构函数,计数减1,如果计数减至0,就删除对象  
  40.     {  
  41.         if (--ptr->use==0)  
  42.         {  
  43.             delete ptr;  
  44.         }  
  45.     }  
  46.       
  47.     int *get_ptr()const{return ptr->ip;}  
  48.     int get_val()const{return val;}  
  49.       
  50.     void set_ptr(int *p){ptr->ip=p;}  
  51.     void set_val(int i){val=i;}  
  52.       
  53.     int get_ptr_val()const{return *ptr->ip;}  
  54.       
  55.     void set_ptr_val(int val){*ptr->ip=val;}  
  56.       
  57. private:  
  58.     U_Ptr *ptr;  
  59.     int val;  
  60. };  
  61.   
  62. int main(int argc, char* argv[])  
  63. {     
  64.     int *p=new int(10);  
  65.     cout<<p<<endl;  
  66.     HasPtr ptr(p,10);  
  67.     cout<<ptr.get_ptr()<<endl;        //两指针指向同一块内存  
  68.     cout<<ptr.get_ptr_val()<<endl;    
  69.       
  70.     delete p;  
  71.     return 0;  
  72. }  

4、定义值型类:三法则(赋值操作符、复制构造函数、析构函数)

  1. #include <string.h>  
  2. #include <iostream.h>  
  3.   
  4. class HasPtr  
  5. {  
  6. public:  
  7.     HasPtr(int *p,int i):ptr(new int(*p)),val(i){} //构造函数  
  8.       
  9.     HasPtr(const HasPtr &orig):ptr(new int(*orig.ptr)),val(orig.val){} //复制构造函数  
  10.       
  11.     HasPtr& operator=(const HasPtr &rhs)  //赋值操作符  
  12.     {  
  13.         if (this!=&rhs)  
  14.         {  
  15.             ptr=new int(*rhs.ptr);  
  16.             val=rhs.val;  
  17.         }  
  18.         return *this;  
  19.     }  
  20.       
  21.     ~HasPtr(){delete ptr;}  //析构函数  
  22.       
  23.     int *get_ptr()const{return ptr;}  
  24.     int get_val()const{return val;}  
  25.       
  26.     void set_ptr(int *p){ptr=p;}  
  27.     void set_val(int i){val=i;}  
  28.       
  29.     int get_ptr_val()const{return *ptr;}  
  30.       
  31.     void set_ptr_val(int val)const{*ptr=val;}  
  32.       
  33. private:  
  34.     int *ptr;  
  35.     int val;  
  36. };  
  37.   
  38. int main(int argc, char* argv[])  
  39. {     
  40.     int *p=new int(10);  
  41.     cout<<p<<endl;  
  42.     HasPtr ptr(p,10);  
  43.     cout<<ptr.get_ptr()<<endl;       //p与ptr的指针不是指在同一块内存,但是所指向的对象内容是一样的  
  44.     delete p;  
  45.     cout<<ptr.get_ptr_val()<<endl;    
  46.     return 0;  
  47. }  
版权声明:本文为博主http://www.feixueteam.net原创文章,未经博主允许不得转载。

c++:成员指针运算符 .* 和 ->*

有一种特殊的指针叫做成员指针,它们通常指向一个类的成员,而不是对象中成员的特定实例。 成员指针并不是真正的指针,它只是成员在对象中的偏移量,它们分别是:.* 和 ->* 。 一个例子: ...
  • CHS007chs
  • CHS007chs
  • 2014年06月17日 17:37
  • 937

C++学习之对象成员指针篇

所谓对象成员指针就是让一个类的对象的指针作为另外一个类的成员变量,对象成员就是让一个类的对象成为另一个类的成员变量。下面以代码举例说明: 公用坐标类: class Coordinate { p...
  • hudfang
  • hudfang
  • 2016年01月14日 18:32
  • 914

C++之类成员指针

一、指向成员变量的指针并非指针          C++中指向成员变量的指针其实是一个相对于类对象的偏移量。《C++必知必会》的条款15讲述了这一说法:“与常规指针不同,一个指向成员变量的指针并不指向...
  • e5Max
  • e5Max
  • 2013年09月14日 14:25
  • 9217

c++ 管理指针成员

c++采用以下三种方式管理指针成员: 1.指针成员采取常规指针型行为。这样的类具有指针的所有缺陷但无需特殊的复制控制。 2.类可以实现所谓的“智能指针”。指针所指向的对象是共享的,但类能够防止悬垂...
  • qdlgdx_lsy
  • qdlgdx_lsy
  • 2013年08月11日 00:33
  • 394

C++类成员指针的意义

C++中,成员指针是最为复杂的语法结构。但在事件驱动和多线程应用中被广泛用于调用回叫函数。在多线程应用中,每个线程都通过指向成员函数的指针来调用该函数。在这样的应用中,如果不用成员指针,编程是非常困难...
  • captain_wangnb
  • captain_wangnb
  • 2016年01月12日 16:54
  • 1172

C/C++中的成员运算符(.)和指针运算符(->)

C语言中: 我们临时定义一个结构体: struct StuInfo{ int num; char name[20]; char sex; float score; }; //初始化两个...
  • fengzei886
  • fengzei886
  • 2014年03月29日 17:48
  • 2047

<C++略识>之对象指针与对象成员指针

对象指针声明方法: 堆中: Coordinate *p = new Coordinate(); //对象指针p指向了new运算符实例化的对象 栈上: Coordinate a; //从栈上实例...
  • u013003827
  • u013003827
  • 2016年07月21日 15:05
  • 449

C++的类成员指针的语法

C++的类成员指针的语法
  • aflyeaglenku
  • aflyeaglenku
  • 2017年07月15日 15:56
  • 389

C++学习笔记(十一):成员访问运算符(点运算和箭头运算)

成员访问运算符 点运算符“.”和箭头运算符“->”,都可以用于访问成员,其中点运算获取类对象的一个成员,箭头运算获取指针指向对象的成员。表达式ptr->men等价于(*ptr).mem:   s...
  • autocyz
  • autocyz
  • 2015年03月20日 22:06
  • 2169

C++中类成员对象与指针的区别

C++编程过程中,在一个类的数据成员是一个类时,定义这个成员变量为对象还是指针是有讲究的。 在C++中, ClassTest objTest;就已经构造了对象,分配了空间 而在C#、Java中,...
  • nbaDWde
  • nbaDWde
  • 2017年03月29日 22:46
  • 430
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:C++管理指针成员
举报原因:
原因补充:

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