标签：
Ordinarily classes that manage resources that do not reside in the class must define the copy-control members. Once a class needs a destructor, it almost surely needs a copy constructor and copy-assignment operator as well.
In order to define these members, we first have to decide what copying an object of our type will mean. In general, we have two choices: we can define the copy operations to make the class behave like a value or like a pointer.
1 #include <string> 2 using std::string; 3 4 class Has_ptr 5 { 6 public: 7 // constructor with default argument 8 Has_ptr(const std::string &s = std::string()) : 9 ps(new std::string(s)), i(0) { } 10 // copy destructor: 11 //each Has_ptr has its own copy of the string to which ps points 12 Has_ptr(const Has_ptr &p) : 13 ps(new std::string(*p.ps)), i(p.i) { } 14 // assignment operator 15 Has_ptr &operator=(const Has_ptr &rhs); 16 // destructor: free the memory allocated in constructor 17 ~Has_ptr() { delete ps; } 18 private: 19 std::string *ps; 20 int i; 21 }; 22 23 // assignment operator: can handle self-assignment 24 Has_ptr &Has_ptr::operator=(const Has_ptr &rhs) 25 { 26 string *newp = new string(*rhs.ps); // copy the underlying string 27 delete ps; // free the old memory 28 ps = newp; // copy data from rhs into this object 29 i = rhs.i; 30 return *this; 31 }
There are two points to keep in mind when you write an assignment operator:
A good pattern to use when you write an assignment operator is to first copy the right-hand operand into a local temporary. After the copy is done, it is safe to destroy the existing members of the left-hand operand. Once the left-hand operand is destroyed, copy the data from the temporary into the members of the left-hand operand.
We‘ll use the synthesized version of the copy constructor. In this case, we have introduced a serious bug! Synthesized copy constructor copy the pointer member, meaning that multiple Has_ptr objects may be pointing to the same memory.
In this case, though, the destructor of Has_ptr cannot unilaterally free its associated string. It can do so only when the last Has_ptr pointing to that string goes away.
When we copy or assign a Has_ptr object, we want the copy and the original to point to the same string.
1 #include <string> 2 using std::string; 3 4 class Has_ptr 5 { 6 public: 7 // constructor allocates a new string and a new counter, which it sets to 1 8 Has_ptr(const std::string &s = std::string()) : 9 ps(new std::string(s)), i(0), use(new std::size_t(1)) { } 10 // copy constructor copies all three data member and increment the counter 11 Has_ptr(const Has_ptr &p) : 12 ps(p.ps), i(p.i), use(p.use) { ++*use; } 13 Has_ptr &operator=(const Has_ptr &rhs); 14 ~Has_ptr(); 15 private: 16 std::string *ps; 17 int i; 18 std::size_t *use; // member to keep track of how many objects share *ps 19 }; 20 21 Has_ptr::~Has_ptr() 22 { 23 if (--*use == 0) // if the reference count goes to 0 24 { 25 delete ps; // delete the string 26 delete use; // delete the counter 27 } 28 } 29 30 // the operator must handle self-assignment. 31 // we do so by increment the count in rhs before 32 // decrementing the count in the left-hand object 33 Has_ptr &Has_ptr::operator=(const Has_ptr &rhs) 34 { 35 ++*rhs.use; // increment the use count of the right-hand operand 36 if (--*use == 0) 37 { // then decrement this object‘s counter 38 delete ps; // if no other users 39 delete use; // free this object‘s allocated members 40 } 41 ps = rhs.ps; // copy data from rhs into this object 42 i = rhs.i; 43 use = rhs.use; 44 return *this; // return this object 45 }
Copy Control and Resource Management
标签：
原文地址：http://www.cnblogs.com/90programmer/p/4237096.html
