C++ Primer 有感（管理类的指针成员）

C++类的指针成员与其他成员有所不同，指针成员指向一个内存地址，该地址的内存需要我没管理。

我现在分析一下为什么要管理指针成员。

有如下Student类，Student.h如下：

[cpp] view plaincopy

1. class Student
2. {
3. public:
4. Student(int *books);
5. virtual ~Student();
6. int *books;
7. };

Student.cpp如下：

[cpp] view plaincopy

1. #include "Student.h"
2. Student::Student(int *books)
3. {
4. this->books=books;
5. }
6. Student::~Student()
7. {
8. }

在主函数中我如下写：

[cpp] view plaincopy

1. #include <iostream>
2. #include "Student.h"
3. using namespace std;
4. int main()
5. {
6. int *b=new int(34);
7. Student s(b);
8. delete b;
9. cout<<(*(s.books))<<endl;
10. return 0;
11. }

当我释放掉了b所指的空间，b的地址就不能用了，但是在s中任然可以访问，所以就出现了不可预知的错误

最后输出的结果如下：

这个指针所指的空间需要我们的Student类来管理，因为我们不知道什么时候该释放掉b的空间，如果手动释放掉b的空间，然后再使用Student对象引用该空间的值，就会出现上面的错误。更复杂的情况是使用一个Student对象初始化另外一个Student对象的时候和赋值的时候。

管理指针成员有两种办法

1.定义智能指针类

2.定义值类型

下面分别介绍

1.智能指针

智能指针：一个行为类似指针但也提供其他功能的类。智能指针的一个通用形式接受指向动态分配对象的指针并负责删除掉该对象，用户分配对象，但由智能指针类删除掉它。智能指针类需要实现复制控制成员来管理指向共享对象的指针。只有在撤销了指向共享对象的最后一个智能指针后，才能删除该共享对象。使用计数是实现智能指针类最常用的方式。

计数类的实现

我先设计一个数据类，目的是察看智能指针的效果。数据类就一个数据，int类型，我主要在析构函数中输出删除了该对象。Flag.h头文件：

[cpp] view plaincopy

1. class Flag {
2. public:
3. Flag(int v);
4. virtual ~Flag();
5. int i;
6. };

Flag.cpp源文件：

[cpp] view plaincopy

1. #include "Flag.h"
2. #include <iostream>
3. Flag::Flag(int v) {
4. // TODO Auto-generated constructor stub
5. i=v;
6. }
7. Flag::~Flag() {
8. std::cout<<"delete the value"<<std::endl;
9. }

下面实现记述类：U_Ptr.h文件：

[cpp] view plaincopy

1. #include "Flag.h"
2. class U_Ptr {
3. public:
4. friend class Student;
5. U_Ptr(Flag *p);
6. virtual ~U_Ptr();
7. private:
8. Flag *books;
9. unsigned int use;
10. };

U_Ptr.cpp源文件：

[cpp] view plaincopy

1. #include "UPtr.h"
2. U_Ptr::U_Ptr(Flag *p) {
3. this->books=p;
4. this->use=1;
5. }
6. U_Ptr::~U_Ptr() {
7. delete books;
8. }

这个类设置Student类为它的友元，以便在Student类中访问该类的私有成员。该类接收一个Flag的指针，该内存在其他地方分配，由U_Ptr类来管理，当该类被释放的时候回收Flag指针所指内存。

下面我完成智能指针类Student，该类决定在什么样的情况下删除Flag指针所分配的内存。

Student.h头文件：

[cpp] view plaincopy

1. #include "UPtr.h"
2. #include "Flag.h"
3. class Student {
4. public:
5. Student(Flag *p);
6. Student(const Student &s);
7. Student& operator=(const Student &s);
8. int getValue();
9. void setValue(int number);
10. virtual ~Student();
11. private:
12. U_Ptr *ptr;
13. };

该类包含了一个U_Ptr对象的指针，在这个类中，要对复制与赋值进行控制。

Student.cpp源文件：

[cpp] view plaincopy

1. #include "Student.h"
2. Student::Student(Flag *p) {
3. this->ptr=new U_Ptr(p);
4. }
5. Student::Student(const Student &s)
6. {
7. this->ptr=s.ptr;
8. ++ptr->use;
9. }
10. Student& Student::operator=(const Student &s)
11. {
12. ++s.ptr->use;
13. if(--ptr->use==0)
14. {
15. delete ptr;
16. }
17. ptr=s.ptr;
18. return *this;
19. }
20. int Student::getValue()
21. {
22. return (ptr->books)->i;
23. }
24. void Student::setValue(int number)
25. {
26. (ptr->books)->i=number;
27. }
28. Student::~Student() {
29. if(--ptr->use==0)
30. {
31. delete ptr;
32. }
33. }

在构造函数中，为ptr指针分配内存，但是这个内存在什么时候释放掉要看该ptr的use的计数，当use为0的时候，说明没有其他的Student类共享该ptr所指内存，这时就释放内存。

在赋值的时候，先将右值的计数加一，本对象的计数应该减一，并且判断这时是否应该释放该对象，然后将右值的ptr赋值给本对象。这样如果是相同的对象赋值的话，有安全的保障。如果先减一，刚好计数为1，会释放内存，然后将计数加一。

在主函数中执行下面的代码会得到我希望的结果：

[cpp] view plaincopy

1. #include <iostream>
2. using namespace std;
3. #include "Flag.h"
4. #include "Student.h"
5. int main() {
6. Flag *f=new Flag(43);
7. Student s1(f);
8. Student s2(s1);
9. return 0;
10. }

打印出   delete the value.

2.定义值类型

这种方法比较简单，看代码了：

Human.h类就是这样的类：

Human.h

[cpp] view plaincopy

1. class Human {
2. public:
3. Human(int value);
4. Human(const Human &value);
5. Human& operator=(const Human &value);
6. virtual ~Human();
7. private:
8. int *ip;
9. };

Human.cpp

[cpp] view plaincopy

1. #include "Human.h"
2. Human::Human(int value) {
3. // TODO Auto-generated constructor stub
4. ip=new int(value);
5. }
6. Human::Human(const Human &value) {
7. // TODO Auto-generated constructor stub
8. ip=new int(*(value.ip));
9. }
10. Human& Human::operator=(const Human& value)
11. {
12. *ip=*(value.ip);
13. return *this;
14. }
15. Human::~Human() {
16. // TODO Auto-generated destructor stub
17. delete ip;
18. }

在构造函数中为指针分配内存，在析构函数中释放内存，在赋值操作中改变指针所指内容的值而不是指针的值。