C++ 拷贝构造函数分析

来源：互联网发布：linux查看网关编辑：程序博客网时间：2024/06/05 19:29
拷贝构造函数，经常被称作X(X&)，是一种特殊的构造函数，他由编译器调用来完成一些基于同一类的其他对象的构件及初始化。它的唯一的一个参数（对象的引用）是不可变的（因为是const型的）。这个函数经常用在函数调用期间于用户定义类型的值传递及返回。拷贝构造函数要调用基类的拷贝构造函数和成员函数。如果可以的话，它将用常量方式调用，另外，也可以用非常量方式调用。  在C++中，下面三种对象需要拷贝的情况。因此，拷贝构造函数将会被调用。  1)． 一个对象以值传递的方式传入函数体  2)． 一个对象以值传递的方式从函数返回  3)． 一个对象需要通过另外一个对象进行初始化  以上的情况需要拷贝构造函数的调用。如果在前两种情况不使用拷贝构造函数的时候，就会导致一个指针指向已经被删除的内存空间。对于第三种情况来说，初始化和赋值的不同含义是构造函数调用的原因。事实上，拷贝构造函数是由普通构造函数和赋值操作赋共同实现的。  拷贝构造函数不可以改变它所引用的对象，其原因如下：当一个对象以传递值的方式传一个函数的时候，拷贝构造函数自动的被调用来生成函数中的对象。如果一个对象是被传入自己的拷贝构造函数，它的拷贝构造函数将会被调用来拷贝这个对象这样复制才可以传入它自己的拷贝构造函数，这会导致无限循环。  除了当对象传入函数的时候被隐式调用以外，拷贝构造函数在对象被函数返回的时候也同样的被调用。换句话说，你从函数返回得到的只是对象的一份拷贝。但是同样的，拷贝构造函数被正确的调用了，你不必担心。  如果在类中没有显式的声明一个拷贝构造函数，那么，编译器会私下里为你制定一个函数来进行对象之间的位拷贝（bitwise copy）。这个隐含的拷贝构造函数简单的关联了所有的类成员。许多作者都会提及这个默认的拷贝构造函数。注意到这个隐式的拷贝构造函数和显式声明的拷贝构造函数的不同在于对于成员的关联方式。显式声明的拷贝构造函数关联的只是被实例化的类成员的缺省构造函数除非另外一个构造函数在类初始化或者在构造列表的时候被调用。  拷贝构造函数是程序更加有效率，因为它不用再构造一个对象的时候改变构造函数的参数列表。设计拷贝构造函数是一个良好的风格，即使是编译系统提供的帮助你申请内存默认拷贝构造函数。事实上，默认拷贝构造函数可以应付许多情况。
 
自己定义的类的对象同样是对象，谁也不能阻止我们用以下的方式进行复制,例如：
#include <iostream>  
using namespace std;  
  
class Test  
{  
public:  
    Test(int temp)  
    {  
        p1=temp;  
    }  
protected:  
    int p1;  
  
};  
  
void main()  
{  
    Test a(99);  
    Test b=a;  
}
普通对象和类对象同为对象，他们之间的特性有相似之处也有不同之处，类对象内部存在成员变量，而普通对象是没有的，
当同样的复制方法发生在不同的对象上的时候，那么系统对他们进行的操作也是不一样的，就类对象而言，相同类型的类对象是
通过拷贝构造函数来完成整个复制过程的，在上面的代码中,我们并没有看到拷贝构造函数，同样完成了复制工作，这又是为什么呢？
因为当一个类没有自定义的拷贝构造函数的时候系统会自动提供一个默认的拷贝构造函数，来完成复制工作。 
下面，我们为了说明情况，就普通情况而言(以上面的代码为例)，我们来自己定义一个与系统默认拷贝构造函数一样的拷贝构造函数，看看它的内部
是如何工作的！ 
代码如下：
#include <iostream>  
using namespace std;  
  
class Test  
{  
public:  
    Test(int temp)  
    {  
        p1=temp;  
    }  
    Test(Test &c_t)//这里就是自定义的拷贝构造函数  
    {  
        cout<<"进入copy构造函数"<<endl;  
        p1=c_t.p1;//这句如果去掉就不能完成复制工作了,此句复制过程的核心语句  
    }  
public:  
    int p1;  
};  
  
void main()  
{  
    Test a(99);  
    Test b=a; 
    cout<<b.p1;  
    cin.get();  
}
上面代码中的Test(Test &c_t)就是我们自定义的拷贝构造函数，拷贝构造函数的名称必须与类名称一致，函数的形式参数是本类型的
一个引用变量,且必须是引用。 
用一个已经初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用，
如果你没有自定义拷贝构造函数的时候系统将会提供给一个默认的拷贝构造函数来完成这个过程，上面代码的复制核心语句就
是通过Test(Test &c_t)拷贝构造函数内的p1=c_t.p1;语句完成的。如果取掉这句代码，那么b对象的p1属性将得到一个未知的随机值；
下面我们来讨论一下关于浅拷贝和深拷贝的问题。 
就上面的代码情况而言，很多人会问到，既然系统会自动提供一个默认的拷贝构造函数来处理复制，
那么我们没有意义要去自定义拷贝构造函数呀，对，就普通情况而言这的确是没有必要的，但在某写状况下，
类体内的成员是需要开辟动态开辟堆内存的,如果我们不自定义拷贝构造函数而让系统自己处理，
那么就会导致堆内存的所属权产生混乱，试想一下，已经开辟的一端堆地址原来是属于对象a的，
由于复制过程发生，b对象取得是a已经开辟的堆地址，一旦程序产生析构，释放堆的时候，计算机是不可能清楚这段地址是真正属于谁的，
当连续发生两次析构的时候就出现了运行错误。 
了更详细的说明问题，请看如下的代码。
#include <iostream>  
using namespace std;  
  
class Internet  
{  
public:  
    Internet(char *name,char *address)  
    {  
        cout<<"载入构造函数"<<endl;  
        strcpy(Internet::name,name);  
        strcpy(Internet::address,address);  
        cname=new char[strlen(name)+1];  
        if(cname!=NULL)  
        {  
            strcpy(Internet::cname,name);  
        }  
    }  
    Internet(Internet &temp)  
    {  
        cout<<"载入COPY构造函数"<<endl;  
        strcpy(Internet::name,temp.name);  
        strcpy(Internet::address,temp.address);  
        cname=new char[strlen(name)+1];//这里注意,深拷贝的体现!  
        if(cname!=NULL)  
        {  
            strcpy(Internet::cname,name);  
        }  
    }  
    ~Internet()  
    {  
        cout<<"载入析构函数!";  
        delete[] cname;  
        cin.get();  
    }  
    void show();  
protected:  
    char name[20];  
    char address[30];  
    char *cname;  
};  
void Internet::show()  
{  
    cout<<name<<":"<<address<<cname<<endl;  
}  
void test(Internet ts)  
{  
    cout<<"载入test函数"<<endl;  
}  
void main()  
{  
    Internet a("中国软件开发实验室","www.cndev-lab.com");  
    Internet b = a;  
    b.show();  
    test(b);  
}
　　上面代码就演示了深拷贝的问题,对对象b的cname属性采取了新开辟内存的方式避免了内存归属不清所导致析构释放空间时候的错误,最后我
 必须提一下，对于上面的程序我的解释并不多，就是希望读者本身运行程序观察变化，进而深刻理解。
　　拷贝和浅拷贝的定义可以简单理解成：如果一个类拥有资源(堆，或者是其它系统资源)，当这个类的对象发生复制过程的时候，
 这个过程就可以叫做深拷贝，反之对象存在资源但复制过程并未复制资源的情况视为浅拷贝。 

　　浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错,这点尤其需要注意！
　　以前我们的教程中讨论过函数返回对象产生临时变量的问题，接下来我们来看一下在函数中返回自定义类型对象是否也遵循此规则产生临时对象！ 
先运行下列代码：
#include <iostream>  
using namespace std;  
  
class Internet  
{  
public:  
    Internet()  
    {  
          
    };  
    Internet(char *name,char *address)  
    {  
        cout<<"载入构造函数"<<endl;  
        strcpy(Internet::name,name);  
    }  
    Internet(Internet &temp)  
    {  
        cout<<"载入COPY构造函数"<<endl;  
        strcpy(Internet::name,temp.name);  
        cin.get();  
    }  
    ~Internet()  
    {  
        cout<<"载入析构函数!";  
        cin.get();  
    }  
protected:  
    char name[20];  
    char address[20];  
};  
Internet tp()  
{  
    Internet b("中国软件开发实验室","www.cndev-lab.com");  
    return b;  
}  
void main()  
{  
    Internet a;  
    a=tp();  
}
　　从上面的代码运行结果可以看出，程序一共载入过析构函数三次，证明了由函数返回自定义类型对象同样会产生临时变量，事实上对象a得到的
    就是这个临时Internet类类型对象temp的值。
　　这一下节的内容我们来说一下无名对象。
　　利用无名对象初始化对象系统不会不调用拷贝构造函数。 
　　那么什么又是无名对象呢？ 
　　很简单，如果在上面程序的main函数中有： 
　　Internet　("中国软件开发实验室","www.cndev-lab.com"); 
　　这样的一句语句就会产生一个无名对象，无名对象会调用构造函数但利用无名对象初始化对象系统不会不调用拷贝构造函数！ 
　　下面三段代码是很见到的三种利用无名对象初始化对象的例子。
#include <iostream>  
using namespace std;  
  
class Internet  
{  
public:  
    Internet(char *name,char *address)  
    {  
        cout<<"载入构造函数"<<endl;  
        strcpy(Internet::name,name);  
    }  
    Internet(Internet &temp)  
    {  
        cout<<"载入COPY构造函数"<<endl;  
        strcpy(Internet::name,temp.name);  
        cin.get();  
    }  
    ~Internet()  
    {  
        cout<<"载入析构函数!";  
    }  
public:  
    char name[20];  
    char address[20];  
};  
  
void main()  
{  
    Internet a=Internet("中国软件开发实验室","www.cndev-lab.com");  
    cout<<a.name;  
    cin.get();  
}
　　上面代码的运行结果有点“出人意料”，从思维逻辑上说，当无名对象创建了后，是应该调用自定义拷贝构造函数，或者是默认拷贝构造函数来
 完成复制过程的，但事实上系统并没有这么做，因为无名对象使用过后在整个程序中就失去了作用，对于这种情况c++会把代码看成是：
 Internet a("中国软件开发实验室",www.cndev-lab.com);
　　省略了创建无名对象这一过程，所以说不会调用拷贝构造函数。

最后让我们来看看引用无名对象的情况。
#include <iostream>    
using namespace std;    
    
class Internet    
{    
public:    
    Internet(char *name,char *address)    
    {    
        cout<<"载入构造函数"<<endl;    
        strcpy(Internet::name,name);    
    }    
    Internet(Internet &temp)    
    {    
        cout<<"载入COPY构造函数"<<endl;    
        strcpy(Internet::name,temp.name);    
        cin.get();    
    }    
    ~Internet()    
    {    
        cout<<"载入析构函数!";    
    }    
public:    
    char name[20];    
    char address[20];    
};    
    
void main()    
{    
    Internet &a=Internet("中国软件开发实验室","www.cndev-lab.com");    
    cout<<a.name;  
    cin.get();    
}
　　引用本身是对象的别名，和复制并没有关系，所以不会调用拷贝构造函数,但要注意的是，在c++看来: 
 Internet &a=Internet("中国软件开发实验室","www.cndev-lab.com"); 
　　是等价与: 
 Internet a("中国软件开发实验室","www.cndev-lab.com"); 
　　的,注意观察调用析构函数的位置（这种情况是在main()外调用，而无名对象本身是在main()内析构的）。