C++ 拷贝构造函数和赋值构造函数

时间 2019-11-12

标签 c++ 拷贝构造函数赋值栏目 C&C++ 繁體版

原文原文链接

转自：http://blog.chinaunix.net/uid-28662931-id-3496326.htmlhtml

1、拷贝构造函数

int main(int argc, char * argv[])  
{  
     CExample A;  
     A.Init40);  
      
     CExample B=A; //把B初始化为A的副本  
     ...  
}

B = A ; 此语句的具体过程:首先创建对象theObjtwo，并调用其构造函数，而后成员被拷贝。
语句"CExample B=A;" 用 A 初始化 B。其完成方式是内存拷贝，复制全部成员的值。完成后，A.pBuffer = B.pBuffer, 即它们将指向一样的地方，指针虽然复制了，但所指向的空间并无复制，而是由两个对象共用了。这样不符合要求，对象之间不独立了，并为空间的删除带来隐患。因此须要采用必要的手段(拷贝构造函数)来避免此类状况。
ide

拷贝构造函数的格式为 : 构造函数名(对象的引用) 提供了拷贝构造函数后的CExample类定义为:
函数

class CExample  
{  
public :  
     CExample(){pBuffer=NULL; nSize=0;}  //构造函数  
     ~CExample(){delete pBuffer;}   // 析构函数  
     CExample(const CExample&); //拷贝构造函数  
    void Init(int n){ pBuffer=new char [n]; nSize=n;}  
private :  
    char *pBuffer; //类的对象中包含指针,指向动态分配的内存资源  
    int nSize;  
};  
  
 //拷贝构造函数的定义  
CExample::CExample(const CExample& RightSides)  
{  
     nSize=RightSides.nSize;    //复制常规成员  
     pBuffer=new char [nSize];    //复制指针指向的内容  
     memcpy(pBuffer,RightSides.pBuffer,nSize*sizeof (char ));  
}

这样，定义新对象，并用已有对象初始化新对象时，即执行语句“CExample B=A; ” 时，CExample(const CExample& RightSides)将被调用，而已有对象用别名RightSides传给构造函数，以用来做复制。原则上，应该为全部包含动态分配成员的类都提供拷贝构造函数。ui

拷贝函数被调用的状况有：
1，定义新对象，并用已有对象初始化新对象时；即执行语句“CExample B=A; ” 时（定义对象时使用赋值初始化）；
2，当对象直接做为参数传给函数时，函数将创建对象的临时拷贝，这个拷贝过程也将调同拷贝构造函数。
this

BOOL testfunc(CExample obj)  
{  
   //针对obj的操做其实是针对复制后的临时拷贝进行的  
}  
testfunc(theObjone); //对象直接做为参数，拷贝函数将被调用；

3，当函数中的局部对象被返回给函数调者时，也将创建此局部对象的一个临时拷贝，拷贝构造函数也将被调用；spa

 CTest func()  
{  
   CTest   theTest;  
   return   theTest  
}

2、赋值符的重载.net

iint main(int argc, char * argv[])  
{  
     CExample A;  
     A.Init(40);  
      
     CExample C;  
     C.Init(60);  
  
     //如今须要一个对象赋值操做,被赋值对象的原内容被清除，并用右边对象的内容填充。  
     C = A;  
    return 0;  
}

用到了"="号，但与上面的例子中语句“ CExample B=A; ” 不一样“ CExample B=A; ”语句中的 "=" 在对象声明语句中，表示初始化。更多时候,这种初始化也可用括号表示。例CExample B(A);

而本例子中，"=" 表示赋值操做。将对象 A 的内容复制到对象C;，这其中涉及到对象C 原有内容的丢弃，新内容的复制。但"="的缺省操做只是将成员变量的值相应复制。旧的值被天然丢弃。因为对象内包含指针，将形成不良后果:指针的值被丢弃了，但指针指向的内容并未释放。指针的值被复制了，但指针所指内容并未复制。所以，包含动态分配成员的类除提供拷贝构造函数外，还应该考虑重载"="赋值操做符号。 unix

类定义变为:指针

class CExample  
{  
public :  
     CExample(){pBuffer=NULL; nSize=0;}  //构造函数  
     ~CExample(){delete pBuffer;}   // 析构函数  
     CExample(const CExample&); //拷贝构造函数  
     CExample& operator = (const CExample&); //赋值符重载  
    void Init(int n){ pBuffer=new char [n]; nSize=n;}  
private :  
    char *pBuffer; //类的对象中包含指针,指向动态分配的内存资源  
    int nSize;  
};  
//赋值操做符重载  
CExample & CExample::operator = (const CExample& RightSides)  
{  
     nSize=RightSides.nSize; //复制常规成员  
    char *temp=new char [nSize]; //复制指针指向的内容   
     memcpy(temp,RightSides.pBuffer,nSize*sizeof (char ));  
  
    delete []pBuffer; //删除原指针指向内容   (将删除操做放在后面，避免X=X特殊状况下，内容的丢失)  
     pBuffer=temp;    //创建新指向  
    return *this   
}

3、拷贝构造函数使用赋值运算符重载的代码code

   一、为何要有拷贝构造函数，它跟构造函数有什么区别？
答：拷贝构造函数其实也是构造函数，只不过它的参数是const 的类自身的对象的引用。若是类里面没有指针成员（该指针成员指向动态申请的空间），是没有必要编写拷贝构造函数的。    咱们知道，若是有一个类CObj，它已经产生了一个对象ObjA，如今又用CObj去建立ObjB，若是程序中使用语句ObjB = ObjA; 也就是说直接使用ObjA的数据给ObjB赋值。这对于通常的类，没有任何问题，可是若是CObj里面有个char * pStr的成员，用来存放动态申请的字符串的地址，在ObjA中使用new 方法动态申请了内存并让ObjA.pStr指向该申请的空间，在OjbB = OjbA以后，ObjA.pStr和ObjB.pStr将同时指向那片空间，这样到致使了谁也不知道到底该由谁来负责释放那块空间，颇有可能致使同一块内存被释放两次。    使用拷贝构造函数，先申请ObjA.pStr所指向的空间大小的空间，而后将空间内容拷贝过来，这样就不会同时指向同一块内存，各自有各自申请的内存，各自负责释放各自申请的内存，从而解决了刚才的问题。因此这里的“拷贝”拷贝的是动态申请的空间的内容，而不是类自己的数据。另外注意到，拷贝构造函数的参数是对象的引用，而不是对象的指针。至于为何要用引用，不可以用指针暂时尚未搞明白，等搞明白了再说。
二、为何要对=赋值操做符进行重载？
   答：接上面的例子，用户在使用语句ObjB = ObjA的时候，或许ObjB的pStr已经指向了动态申请的空间，若是直接简单将其指向的地址覆盖，就会致使内存泄露，因此须要对=赋值操做符进行重载，在重载函数中判断pStr若是已经指向了动态申请的空间，就先将其释放。
三、拷贝构造函数和=赋值操做符重载的关系。
   答：从原文的例子中能够看出，=赋值操做符重载比拷贝构造函数作得要多，它除了完成拷贝构造函数所完成的拷贝动态申请的内存的数据以外，还释放了本来本身申请的内存空间。因此原文最后给出的拷贝构造函数的实现可使用=赋值操做符的重载来完成。
四、拷贝构造函数什么时候被调用？
   a.对象的直接赋值也会调用拷贝构造函数  ；
    b.函数参数传递只要是按值传递也调用拷贝构造函数；
   c.函数返回只要是按值返回也调用拷贝构造函数。

4、拷贝构造函数和赋值运算符重载为何要使用引用？

首先先说下基类和派生类的关系：
例如：

 class Derived：public Base  
  {  
           public：  
             .....  
           private：  
               .......  
   }；

首先，派生类对象的引用初始化基类引用。多态性的动态绑定中存在两个条件：1，必须是virtual 函数（虚函数）；2，必须是经过基类的引用或基类的指针进行成员函数的调用。

因为派生类中存在基类的成员，也就至关于一个派生类对象中包含了一个基类对象，因此能够采用一个基类引用来绑定一个派生类对象。引用实质上是针对一块内存区域，引用是一个标号，是这块内存区域的一个名字，一个引用与一块内存区域绑定，由于派生对象中存在基类部分，能够认为派生对象的区域中存在基类对象，这时可用基类的引用来代表这块内存区域，即采用一个基类的别名来表示（绑定）这段内存区域，派生对象的地址（这段内存）以及内容都没有发生改变，也没有重现创造出一个新的对象，基类的引用仍是指向这个派生对象。对于指针的分析方式类似。所以能够采用基类的引用绑定派生类对象。

可是如何实现派生类对象到基类的转换呢？

这时候的转换与前面的绑定存在很大的差异，由于这是从新分配一个基类对象，而再也不是引用问题，再也不是绑定问题，是依据一个派生类对象生成一个新的基类对象。由于派生类对象中存在一个基类对象基本的信息，彻底能够生成一个基类对象，彻底将此过程看做是一个初始化或者赋值的问题。也就是采用派生类建立一个新的对象或者赋值一个对象。

    从上面的分析咱们能够采用下面的形式来实现：
    Base(const Derived &);
     Base &operator=(const Derived &);

是在基类函数中采用构造函数基于派生类来重载一系列的构造函数，可是这也存在一个问题，若是存在不少派生类，这时候就要重载不少构造函数，这确定不是咱们须要的。

这时候咱们发现对于一个类而言，为何复制构造函数和重载赋值操做符这么重要了。由于这两个函数都是接受一个基类的引用，根据前面的分析咱们知道一个基类引用彻底能够绑定一个派生类的对象，而派生类对象中又包含了一个基类对象的基本信息。咱们可以实现一个从一个派生对象到基类的构造过程。
咱们用一个基类引用绑定一个派生对象，而后采用基类引用对基类成员进行访问，完成了一个基类对象基本要素的填充操做，至关于完成了基类对象的建立，也就是构造问题。这样也就能完成由派生类对象到基类对象的构造过程。

总结起来讲了，由于在复制构造函数中，C++中的基类引用能够绑定一个派生类的对象，若是在容许访问的状况下，采用基类引用能够访问基类的成员以及派生类的其余成员，采用引用能够复制派生类对象中基类成员的值到新建立的基类成员中，完成一个基类成员数据的填充操做，这时候一个完整的基类对象就建立完成了。

重载赋值操做符则是发生在使用一个派生对象来赋值一个基类对象时，这时候也是const基类引用绑定一个派生类对象，而后复制对应的基类成员到基类对象对于的成员中，完成一个基类对象成员的更新操做。

复制构造函数不只仅实现了同类型之间的初始化操做，同时也完成了采用一个派生类对象初始化一个基类对象的操做，重载赋值操做符实现了同类型之间的赋值操做，也完成了采用派生类对象赋值基类对象的操做。若是没有这两个函数的存在，也就不能完成派生类到基类的赋值和初始化操做。这也是为何必定会存在这两个函数的缘由。

继承方式	基类特性	派生类特性
公有继承	public	public
公有继承	protected private	protected 不可访问
私有继承	public	private
私有继承	protected private	private 不可访问
保护继承	public	protected
保护继承	protected private	protected不可访问

C++ 拷贝构造函数和赋值构造函数

1、拷贝构造函数

4、拷贝构造函数 和 赋值运算符重载 为何要使用引用？

4、拷贝构造函数和赋值运算符重载为何要使用引用？