C++Primer笔记之复制控制

复制控制这一节需要注意的地方不多，主要有以下几点：

1、定义自己的复制构造函数

什么时候需要定义自己的复制构造函数，而不用系统提供的，主要遵循以下的经验说明：

某些类必须对复制对象时发生的事情加以控制，这样的类（1）经常有一个数据成员是指针，（2）有成员在构造函数中分配的其他资源；

而另一些类在创建对象时必须做一些特定的工作。

2、禁止复制

有些类是需要禁止复制的，如iostream类就不允许复制，但编译器始终都会默认合成一个，但还是有办法的：

为了防止复制，类只要显示声明其复制构造函数为private就行了。

然而，这样，类的友元和成员仍可以进行复制，如果想要连友元和成员中的复制也禁止，就可以声明一个private复制构造函数但不对其定义，这是合法的。

3、析构函数的异同

与复制构造函数或赋值操作符不同，编译器总是会为我们合成一个析构函数，合成析构函数按照对象创建时的逆序撤销每个非static成员。

析构函数与复制构造函数或赋值操作符之间的一个重要区别是：即使我们编写了自己的析构函数，合成析构函数仍然会运行。合成析构函数。

4、智能指针

智能指针是由于在有指针成员的类中，指针所指向的对象是共享的，防止出现悬垂指针而提出的一种管理指针的办法。

为了阐述智能指针，我们来看一个例子：

 class HasPtr{
 public:
     HasPtr(int *p, int i):uptr(p), val(i) {} //p是指向int型数组的指针
     HasPtr& operator = (const HasPtr& rhs);
     int *getPtr() {
         return uptr->ip;
     }
     int getValue() {
         return val;
     }

     void setPtr(int *p) {
         uptr->ip = p;
     }
     void setValue(int i) {
         val = i;
     }

     int getPtrValue() const {
         return *uptr->ip;
     }
     void setPtrValue(int i) {
         *uptr->ip = i;
     }

 private:
     int *uptr;
     int val;
 };

如上一个类，如果我像这样调用：

int obj = 0;

HasPtr ptr1(&obj, 42);

HasPtr ptr2(ptr1);

ptr1和ptr2的值相同，改变任意一个的值都可以改变其共享对象的值。

再看，可能出现悬垂指针的情况：

int *ip = new int(42);

HasPtr ptr(ip, 10);

delete ip;

ptr.set_ptr_val(0); //Disaster!!!

这里ip和ptr中的指针指向了同一对象，删除了该对象时，ptr中的指针不再指向有效对象，但是你又不知道该对象不在了，所以，这样就出现了悬垂指针。

所以，定义智能指针能有效地解决这个问题，为了避免多个指针共享一个对象时撤销出现的悬垂指针问题，定义智能指针类的主要功能就是来保证在撤销指向对象的最后一个指针时才删除该对象。

为了统计指向共享对象的指针的数量，引入使用计数，用其跟踪该类有多少个对象共享同一指针，但使用计数为0时，删除对象。在设计上，将使用计数设计成一个单独的类，用来封装使用计数和相关指针。

如下：

 //仅由HasPtr使用的U_Ptr类，用于封装使用计数和相关指针
 class U_Ptr {
     friend class HasPtr; //定义成友元
     size_t use;
     int *ip;
     U_Ptr(int *p):ip(p), use() {}
     ~U_Ptr() { delete ip; }
 };

引用上面的那个类，不同的是，让HasPtr类保存一个指向U_Ptr对象的指针，U_Ptr对象再指向实际的int基础对象。如下：

 class HasPtr{
 public:
     HasPtr(int *p, int i):uptr(new U_Ptr(p)), val(i) {} //p是指向int型数组的指针
     HasPtr(const HasPtr& orig):uptr(orig.uptr),val(orig.val) {
         ++uptr->use;  //复制完成将使用计数加1
     }
     HasPtr& operator = (const HasPtr& rhs);
     ~HasPtr() {
         if(--uptr->use == 0) //检查假如只有一个对象在共享该指针，则删除
             delete uptr;
     }

     int *getPtr() {
         return uptr->ip;
     }
     int getValue() {
         return val;
     }

     void setPtr(int *p) {
         uptr->ip = p;
     }
     void setValue(int i) {
         val = i;
     }

     int getPtrValue() const {
         return *uptr->ip;
     }
     void setPtrValue(int i) {
         *uptr->ip = i;
     }

 private:
     U_Ptr *uptr;
     int val;
 };

其中，红色部分是改动过的。赋值操作符像下面这样：

 HasPtr& HasPtr::operator =(const HasPtr &rhs)
 {
     ++ rhs.uptr->use;
     if (--uptr->use == )
         delete uptr;
     uptr = rhs.uptr;
     val = rhs.val;
     return *this;
 }

还有一种方法是定义值类型：
这种思路很简单，就是给指针成员提供值语义，复制值型对象时，会得到一个不同的新副本，对副本所做的改变不会反映在原有对象上。如下，可以对赋值操作符做点改变：

 HasPtr& HasPtr::operator =(const HasPtr &rhs)
 {
     *uptr = *rhs.uptr;
     val = rhs.val;
     return *this;
 }