阿里电话面试详解

清疚 2022-08-02 15:41 188阅读 0赞

上一篇疏忽了一个问题，面试官还问了这么一个问题：深拷贝和浅拷贝，当时只是说了一下概念，并不会仔细说来。查了一下资料，做个总结：

对于普通类型的对象来说，它们之间的复制是很简单的，例如：  
int a=88;  
int b=a;  
而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量。下面看一个类对象拷贝的简单例子。

![None.gif][] \#include  < iostream >   
![None.gif][] using  namespace  std;  
![None.gif][]  
![ExpandedBlockStart.gif][] class  CExample  \{  
![InBlock.gif][]private:  
![InBlock.gif][] 　int a;  
![InBlock.gif][]public:  
![InBlock.gif][] 　CExample(int b)  
![ExpandedSubBlockStart.gif][] 　\{ a=b;\}  
![InBlock.gif][] 　void Show ()  
![ExpandedSubBlockStart.gif][] 　\{  
![InBlock.gif][] cout<<a<<endl;  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\} ;  
![None.gif][]  
![None.gif][] int  main()  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][] 　CExample A(100);  
![InBlock.gif][] 　CExample B=A;  
![InBlock.gif][] 　B.Show ();  
![InBlock.gif][] 　return0;  
![ExpandedBlockEnd.gif][]\}

运行程序，屏幕输出100。从以上代码的运行结果可以看出，系统为对象B分配了内存并完成了与对象A的复制过程。就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。下面举例说明拷贝构造函数的工作过程。

![None.gif][] \#include  < iostream >   
![None.gif][] using  namespace  std;  
![None.gif][]  
![ExpandedBlockStart.gif][] class  CExample  \{  
![InBlock.gif][]private:  
![InBlock.gif][]int a;  
![InBlock.gif][]public:  
![InBlock.gif][] CExample(int b)  
![ExpandedSubBlockStart.gif][]\{ a=b;\}  
![InBlock.gif][]  
![InBlock.gif][] CExample(const CExample& C)  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][] a=C.a;  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]void Show ()  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][] cout<<a<<endl;  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\} ;  
![None.gif][]  
![None.gif][] int  main()  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][] CExample A(100);  
![InBlock.gif][] CExample B=A;  
![InBlock.gif][] B.Show ();  
![InBlock.gif][]return0;  
![ExpandedBlockEnd.gif][]\}

CExample(const CExample& C)就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它的唯一的一个参数是本类型的一个引用变量，该参数是const类型，不可变的。例如：类X的拷贝构造函数的形式为X(X& x)。

当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：  
一个对象以值传递的方式传入函数体  
一个对象以值传递的方式从函数返回  
一个对象需要通过另外一个对象进行初始化。

如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝，后面将进行说明。

自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。  
  
浅拷贝和深拷贝

在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。

深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。下面举个深拷贝的例子。

\#include <iostream>  
using namespace std;  
class CA  
\{  
　public:  
　　CA(int b,char\* cstr)  
　　\{  
　　　a=b;  
　　　str=new char\[b\];  
　　　strcpy(str,cstr);  
　　\}  
　　CA(const CA& C)  
　　\{  
　　　a=C.a;  
　　　str=new char\[a\]; //深拷贝  
　　　if(str!=0)  
　　　　strcpy(str,C.str);  
　　\}  
　　void Show()  
　　\{  
　　　cout<<str<<endl;  
　　\}  
　　~CA()  
　　\{  
　　　delete str;  
　　\}  
　private:  
　　int a;  
　　char \*str;  
\};

int main()  
\{  
　CA A(10,"Hello!");  
　CA B=A;  
　B.Show();  
　return 0;  
\}  
  
深拷贝和浅拷贝的定义可以简单理解成：如果一个类拥有资源(堆，或者是其它系统资源)，当这个类的对象发生复制过程的时候，这个过程就可以叫做深拷贝，反之对象存在资源，但复制过程并未复制资源的情况视为浅拷贝。

浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错。

Test(Test &c\_t)是自定义的拷贝构造函数，拷贝构造函数的名称必须与类名称一致，函数的形式参数是本类型的一个引用变量,且必须是引用。

当用一个已经初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用，如果你没有自定义拷贝构造函数的时候，系统将会提供给一个默认的拷贝构造函数来完成这个过程，上面代码的复制核心语句就是通过Test(Test &c\_t)拷贝构造函数内的p1=c\_t.p1;语句完成的。

[None.gif]: /images/20220731/577dad98c02748558e0d17dade95b5a9.png
[ExpandedBlockStart.gif]: /images/20220731/83aa82ecb69f442baf0672a5096229e8.png
[InBlock.gif]: /images/20220731/3ac1472e58fa48ab9e640491da3d68ac.png
[ExpandedSubBlockStart.gif]: /images/20220731/660d1737668c4de1b5763c4a0ef32b66.png
[ExpandedSubBlockEnd.gif]: /images/20220731/dace60be1c8b4d919d0ef18c37edd8ca.png
[ExpandedBlockEnd.gif]: /images/20220731/7d6eec4edebb4e279c8275e0f125fbc2.png