C++管理指针成员

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

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

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

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

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

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

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

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

4、定义值型类：三法则（赋值操作符、复制构造函数、析构函数）

1. #include <string.h>
2. #include <iostream.h>
3. class HasPtr
4. {
5. public:
6. HasPtr(int *p,int i):ptr(new int(*p)),val(i){} //构造函数
7. HasPtr(const HasPtr &orig):ptr(new int(*orig.ptr)),val(orig.val){} //复制构造函数
8. HasPtr& operator=(const HasPtr &rhs)  //赋值操作符
9. {
10. if (this!=&rhs)
11. {
12. ptr=new int(*rhs.ptr);
13. val=rhs.val;
14. }
15. return *this;
16. }
17. ~HasPtr(){delete ptr;}  //析构函数
18. int *get_ptr()const{return ptr;}
19. int get_val()const{return val;}
20. void set_ptr(int *p){ptr=p;}
21. void set_val(int i){val=i;}
22. int get_ptr_val()const{return *ptr;}
23. void set_ptr_val(int val)const{*ptr=val;}
24. private:
25. int *ptr;
26. int val;
27. };
28. int main(int argc, char* argv[])
29. {
30. int *p=new int(10);
31. cout<<p<<endl;
32. HasPtr ptr(p,10);
33. cout<<ptr.get_ptr()<<endl;       //p与ptr的指针不是指在同一块内存，但是所指向的对象内容是一样的
34. delete p;
35. cout<<ptr.get_ptr_val()<<endl;
36. return 0;
37. }

版权声明：本文为博主http://www.zuiniusn.com原创文章，未经博主允许不得转载。