构造函数与拷贝解析

当我们声明一个类的时候，可能会需要另外一个类的实体去初始化一个新定义的类。

// 类定义
// 此类只能实现数据的拷贝，而不能够对资源进行操作。
class ScreenOnlyCopyData
...{
public:
      short height()...{/**//* ... */}
      short weight()...{/**//* ... */}
      string  screen()...{/**//*...*/}

private:
     string _screen;
     string::size_type _cursor;
     short   _height,_weight;
};

//当有一个类对象实现时，
        ScreenOnlyCopyData s1;
        //对s1进行操作.....
      ScreenOnlyCopyData s2=s1;
     //等同于下面的语句
        s2._screen = s1._screen;
        s2._cursor = s1._cursor;
        s2._height = s1._height;
        s2._weight = s1._weight;
//所以，当我们定义了一个带有资源分配的类类型时，在类之间相互拷贝必须重新构造拷贝构造函数，
// 否则将只对值进行简单的赋值过程，最终导致两个类对象指向同一个资源，在其中一个对象将
// 资源析构时，另一个对象原本指向资源的指针将指向一个未定义的资源，从而导致错误的发生。
// 具体见下面的代码，为使分析简单，仅使用两个成员。

Class NoResourceToCopy
...{
public:
      NewResource(size_type len)...{*p = new int [len];} 
      ~NoResourceToCopy()...{delete []p;}
private:
       int *p;
       int s;
};

NoResourceToCopy nr1;
nr1.NewResource(10);
NoResourceToCopy nr2=nr1;               //特殊语句1
//按上面的解释，这特殊语句1应该等同于下面的语句的集合
// nr2.p=nr1.p;
// nr2.s=nr2.s;
// 所以，当nr1析构时，nr2中的p指向的内存块是不明确的，因此会出现错误。
// 因此为使特殊语句1能够成功获取资源，需要如下的定义。

Class RecourseToCopy
...{
public:
    RecourseToCopy()...{}
    ResourceToCopy( ResourceToCopy & )
   ...{}
   ~RecourseToCopy()...{}
private:
    int *p;
    int len;
};

RecourseToCopy::ResouceToCopy()
...{
    *p =NULL:
   len= 0;
}

ResourceToCopy::ResourceToCopy(ResourceToCopy &s)
...{
   if(NULL == s.p)
    ...{      
        this->p=NULL;
        this->len=0;
   }
   this->p=new int[s1.len];   //只有在此处再次申请资源，才能保证s1被解析时，p不是野指针。
   this->len =s1.len;
}
ResourceToCopy ::~ResouceToCopy()
...{
     delete []p;
}