Design and use of smart pointers in C + +

smart pointer (smart pointer) is a class that stores pointers to dynamically allocated (heap) objects and is used for lifetime control to ensure that dynamically allocated objects are destroyed automatically and correctly to prevent memory leaks. One of its common implementation techniques is the use of reference counts (reference count). The smart pointer class relates a counter to the object that the class points to, and the reference count tracks how many objects in the class share the same pointer. Each time a new object of the class is created, the pointer is initialized and the reference count is set to 1, and when the object is created as a copy of another object, the copy constructor copies the pointer and increments the corresponding reference count; When an object is assigned, the assignment operator reduces the reference count of the object referred to by the left operand, if the reference count is reduced Delete the object) and increase the reference count of the object referred to by the right operand; when the destructor is called, the constructor reduces the reference count (if the reference count is reduced to 0, the base object is deleted). A smart pointer is a class that simulates a pointer action. All smart pointers are overloaded with and * operators. Smart pointers also have many other features that are more useful for automatic destruction. This is mainly the use of the finite scope of the stack object and the temporary object (finite scope implementation) destructor to free memory. Of course, smart pointers are more than that, including the ability to modify source objects when copying. The smart pointer is different according to the requirements, the design is also different (copy on write, assignment is to release the object has permissions, reference count, etc.). Auto_ptr is a common smart pointer.
Smart pointers are typically implemented with class templates:
[CPP]View Plaincopy

2. Template <class t>
4. Class Smartpointer
6. {
8. Private
10. T *_ptr;
12. Public
14. Smartpointer (T *p): _ptr (P) //constructor
16. {
18. }
20. t& operator * () //overloaded * operator
22. {
24. return *_ptr;
26. }
28. t* operator---() //heavy-duty operator
30. {
32. return _ptr;
34. }
36. ~smartpointer () //destructor
38. {
40. Delete _ptr;
42. }
44. };

There are two classic strategies for implementing reference counting, one of which will be used here, where you need to define a separate concrete class to encapsulate the reference count and related pointers:
[CPP]View Plaincopy

2. Defines the U_ptr class that is used only by the Hasptr class to encapsulate usage counts and related pointers
4. All members of this class are private, and we don't want ordinary users to use the U_ptr class, so it doesn't have any public members
6. Set the Hasptr class to friends so that its members can access the members of U_PTR
8. Class U_ptr
10. {
12. friend class Hasptr;
14. int *ip;
16. size_t use;
18. U_PTR (int *p): IP (P), use (1)
20. {
22. cout << "U_ptr constructor called!" << Endl;
24. }
26. ~u_ptr ()
28. {
30. Delete IP;
32. cout << "u_ptr distructor called!" << Endl;
34. }
36. };

The Hasptr class needs a destructor to remove the pointer. However, the destructor cannot remove the pointer unconditionally. ”
The condition is the reference count. If the object is referred to by two pointers, then deleting one of the pointers does not invoke the destructor for the pointer, because there is another pointer pointing to the object at this point. It appears that the smart pointer is primarily to prevent improper destructor behavior and to prevent dangling pointers from appearing.

As shown, hasptr is the smart pointer, U_ptr is the counter, there is a variable use and pointer Ip,use records the *IP object is referred to by how many hasptr objects. Assuming now another two Hasptr object P1, P2 point to u_ptr, then I delete p1,use variable will be reduced by 1, u_ptr will not be destructor, then u_ptr point to the object is not destructor, then P2 still point to the original object, and not become a dangling pointer. When delete P2, the use variable will be reduced from 1 to 0. At this point, the U_ptr object is refactored, then the object pointed to by U_ptr is also refactored to ensure that no memory leaks occur.
Classes that contain pointers need to pay particular attention to replication control, because copying the pointer only copies the address in the pointer, not the object pointed to by the pointer.
Most C + + classes manage pointer members in one of three ways
(1) Regardless of the pointer member. Copy only the pointer, not the object pointed to by the pointer. When one of the pointers releases the space of the object it points to, the other pointers become floating pointers. This is an extreme
(2) Copy the pointer when copying, and also copy the object pointed to by the pointer. This can result in wasted space. It is not necessarily necessary to copy the object to which the pointer is pointing.
(3) The Third kind is a kind of compromise way. A secondary class is used to manage the replication of pointers. There is a pointer to the auxiliary class in the original class, the data member of the auxiliary class is a counter and a pointer (pointing to the original) (this is how the smart pointer is implemented).
In fact, the reference count of smart pointers is similar to the Java garbage collection mechanism: Java's decision to refuse is simple, if an object is not referenced, then the object is garbage. The system can be recycled.
The HASPTR smart pointer is declared as follows, a pointer to the U_ptr object is saved, and the U_ptr object points to the actual int base object, the code is as follows:
[CPP]View Plaincopy

2. #include <iostream>
4. Using namespace std;
8. Defines the U_ptr class that is used only by the Hasptr class to encapsulate usage counts and related pointers
10. All members of this class are private, and we don't want ordinary users to use the U_ptr class, so it doesn't have any public members
12. Set the Hasptr class to friends so that its members can access the members of U_PTR
14. Class U_ptr
16. {
18. friend class Hasptr;
20. int *ip;
22. size_t use;
24. U_PTR (int *p): IP (P), use (1)
26. {
28. cout << "U_ptr constructor called!" << Endl;
30. }
32. ~u_ptr ()
34. {
36. Delete IP;
38. cout << "u_ptr distructor called!" << Endl;
40. }
42. };
46. Class Hasptr
48. {
50. Public
52. //constructor: P is a pointer to an int object that has been created dynamically
54. HASPTR (int *p, int i): ptr (new U_ptr (P)), Val (i)
56. {
58. cout << "Hasptr constructor called!" << "use =" << ptr->use << Endl;
60. }
64. //Copy constructor: Copy member and use Count plus 1
66. Hasptr (const hasptr& orig): ptr (Orig.ptr), Val (orig.val)
68. {
70. ++ptr->use;
72. cout << "Hasptr copy constructor called!" << "use =" << ptr->use << Endl;
74. }
78. //Assignment operator
80. hasptr& operator= (const hasptr&);
84. //destructor: Delete the U_ptr object if the count is 0
86. ~hasptr ()
88. {
90. cout << "hasptr distructor called!" << "use =" << ptr->use << Endl;
92. if (--ptr->use = = 0)
94. delete ptr;
96. }
100. //Get data members
102. int *get_ptr () const
104. {
106. return ptr->ip;
108. }
110. int Get_int () const
112. {
114. return Val;
116. }
120. //Modify data members
122. void set_ptr (int *p) const
124. {
126. Ptr->ip = p;
128. }
130. void Set_int (int i)
132. {
134. val = i;
136. }
140. //Returns or modifies the base int object
142. int Get_ptr_val () const
144. {
146. return *ptr->ip;
148. }
150. void Set_ptr_val (int i)
152. {
154. *ptr->ip = i;
156. }
158. Private
160. U_ptr *ptr; //point to use the Count class U_ptr
162. int val;
164. };
166. hasptr& Hasptr::operator = (const hasptr &RHS) //Note, here the assignment operator adds 1 to the use of RHS before reducing the use count of the operands, thus preventing self-assignment
168. {
170. //Increase usage count in right-hand operand
172. ++rhs.ptr->use;
174. //The use count of the left operand object is reduced by 1, and if the object's usage count is reduced to 0, the object is deleted
176. if (--ptr->use = = 0)
178. delete ptr;
180. ptr = rhs.ptr; //Copy u_ptr pointer
182. val = rhs.val; //Copy int member
184. return * this;
186. }
190. int main (void)
192. {
194. int *pi = new int (42);
196. Hasptr *HPA = new Hasptr (pi, 100); //Constructors
198. Hasptr *HPB = new Hasptr (*HPA); //copy constructor
200. Hasptr *HPC = new Hasptr (*HPB); //copy constructor
202. Hasptr HPD = *HPA; //Copy constructor
206. cout << hpa->get_ptr_val () << "<< hpb->get_ptr_val () << Endl;
208. Hpc->set_ptr_val (10000);
210. cout << hpa->get_ptr_val () << "<< hpb->get_ptr_val () << Endl;
212. Hpd.set_ptr_val (10);
214. cout << hpa->get_ptr_val () << "<< hpb->get_ptr_val () << Endl;
216. Delete hpa;
218. Delete HPB;
220. Delete HPC;
222. cout << hpd.get_ptr_val () << Endl;
224. return 0;
226. }

The assignment operator here is troublesome, and let me analyze it with a chart:
Suppose you now have two smart pointers, p1, p2, a point of memory with content 42, and a pointer to 100 of memory, such as:

Now, I'm going to do the assignment, p2 = p1. Compared with the above
[CPP]View Plaincopy

1. hasptr& operator= (const hasptr&); //assignment operator

At this point, RHS is P1, first, the P1 point to the PTR's use plus 1,
[CPP]View Plaincopy

1. ++rhs.ptr->use; //Increase usage count in right-hand operand

Then, do:
[CPP]View Plaincopy

1. if (--ptr->use = = 0)
2. delete ptr;

Because the original P2 object is now P2 not pointing, then the object is less a pointer to refer to, so, use do self minus 1;
At this point, the condition is established. Because the use of U2 is 1. Then, run the U_ptr destructor, and in the U_ptr destructor, do the delete IP operation, so freed the memory, there is no memory leak problem.
The next operation is natural, needless to say:
[CPP]View Plaincopy

1. ptr = rhs.ptr; //Copy u_ptr pointer
2. val = rhs.val; //Copy int member
3. return * this;

After the assignment is done, it becomes as shown. The red label is the changed part:

It is also important to note that when overloading the assignment operator, it is important to note that the self-assignment is checked.
：

At this point, do p1 = p1 operation. So, first of all, the u1.use is increased by 1, which is 2, then the U1.use is reduced by 1 to 1. Then the delete operation is not performed and the rest of the operation can proceed smoothly. According to the C + + primer, "This assignment operator reduces the use count of RHS by 1 before reducing the use count of the left operand, thus preventing itself from being assigned". Hey, I understand that anyway. Of course, the assignment operator function can be as normal as it is:
[CPP]View Plaincopy

1. if (this= = &RHS)
2. return * this;

Running results such as:

Reprint please indicate source, original address: http://blog.csdn.net/hackbuteer1/article/details/7561235

Design and use of smart pointers in C + +