本文详细介绍了C++中的拷贝构造函数，包括其定义、作用及调用时机，如作为函数参数、返回值时的调用。还探讨了浅拷贝与深拷贝的概念，解释了默认拷贝构造函数如何处理动态成员，并给出了防止默认拷贝的策略。此外，讨论了拷贝构造函数为何必须为引用传递，以及其在类中调用私有成员的能力。最后，总结了构造函数和析构函数在面试中的常见问题，如构造函数的重载、析构函数的虚函数特性以及何时需要定义拷贝构造函数。
【拷贝构造函数】c++类拷贝构造函数详解
一、什么是拷贝构造函数
也称为复制构造函数。
复制构造函数参数为类对象本身的引用，根据一个已存在的对象复制出一个新的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中。
先来看一个例子：
定义一个Time类，该类有三个公有成员 Hour，Minute，Second。
将该类定义在“Time.h”的头文件里。建一个main.cpp用来放主函数。
“Time.h”：
#include<iostream>
using namespace std;
class Time {
private:
int Hour;
int Minute;
int Second;
public:
//构造函数列表初始化
Time()
{
cout << "constructor1 is called" << endl;
}
Time(int tmphou, int tmpmin, int tmpsec) :Hour(tmphou), Minute(tmpmin), Second(tmpsec)
{
cout << "constructor2 is called" << endl;
}
//拷贝构造函数
Time(const Time& tmptime)
{
cout << "copy constructor is called" << endl;
}
~Time()
{
cout << "destructor is called" << endl;
}
void print()
{
cout << Hour << ' ' << Minute << ' ' << Second << endl;
}
};
“main.cpp”：
#include<iostream>
#include"Time.h"
using namespace std;
int main()
{
Time mytime;
Time mytime0(1, 2, 3);
Time mytime1(mytime0); //也可写为Time mytime1 = mytime0;
mytime1.print();
return 0;
}
最终输出：
constructor1 is called //mytime构造函数
constructor2 is called //mytime0构造函数
copy constructor is called //mytime1对mytime0的拷贝
-858993460 -858993460 -858993460
destructor is called //mytime1
destructor is called //mytime0
destructor is called //mytime
（由于我的拷贝构造函数啥都没写，只有输出，所以并没有真的复制）
（该例子也为 对象需要通过另外一个对象进行初始化 时的构造函数）
从以上代码的运行结果可以看出，系统为对象 mytime1 分配了内存并完成了与对象 mytime0 的复制过程。就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。
Time(const Time& tmptime)；就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它的一个参数是本类型的一个引用变量。
二、拷贝构造函数的几种调用时机
1. 当函数的参数为类的对象时
在类外增加一个函数func();，来调用Time类型变量。
“Time.h”：
#include<iostream>
using namespace std;
class Time {
private:
int Hour;
int Minute;
int Second;
public:
//构造函数列表初始化
Time()
{
cout << "constructor1 is called" << endl;
}
Time(int tmphou, int tmpmin, int tmpsec) :Hour(tmphou), Minute(tmpmin), Second(tmpsec)
{
cout << "constructor2 is called" << endl;
}
//拷贝构造函数
Time(const Time& tmptime)
{
cout << "copy constructor is called" << endl;
}
~Time()
{
cout << "destructor is called" << endl;
}
void print()
{
cout << Hour << ' ' << Minute << ' ' << Second << endl;
}
};
void func(Time tmptime) //新增
{
cout << "ordinary function is called" << endl;
}
“main.cpp”：
#include<iostream>
#include"Time.h"
using namespace std;
int main()
{
Time mytime;
Time mytime0(1, 2, 3);
Time mytime1 = mytime0;
mytime1.print();
func(mytime0); //新增
return 0;
}
最终输出：
constructor1 is called //mytime构造函数
constructor2 is called //mytime0构造函数
copy constructor is called //mytime1对mytime0的拷贝
-858993460 -858993460 -858993460
copy constructor is called //A对mytime0的拷贝
ordinary function is called //函数
destructor is called //A
destructor is called //mytime1
destructor is called //mytime0
destructor is called //mytime
调用 func() 时，会产生以下几个重要步骤：
(1) mytime0 对象传入形参时，会先会产生一个临时变量，就叫 A 吧。
(2) 然后调用拷贝构造函数把 mytime0 的值给 A 。 整个这两个步骤有点像：Time A(mytime0);
(3) 等func()执行完后, 析构掉 A 对象。
2. 函数的返回值是类的对象
“Time.h”：
#include<iostream>
using namespace std;
class Time {
private:
int Hour;
int Minute;
int Second;
public:
//构造函数列表初始化
Time()
{
cout << "constructor1 is called" << endl;
}
Time(int tmphou, int tmpmin, int tmpsec) :Hour(tmphou), Minute(tmpmin), Second(tmpsec)
{
cout << "constructor2 is called" << endl;
}
//拷贝构造函数
Time(const Time& tmptime)
{
cout << "copy constructor is called" << endl;
}
~Time()
{
cout << "destructor is called" << endl;
}
};
Time func()
{
cout << "ordinary function is called" << endl;
Time tmptime(1,2,3);
return tmptime; //返回类的对象
}
“main.cpp”：
#include<iostream>
#include"Time.h"
using namespace std;
int main()
{
//Time mytime;
//Time mytime0(1, 2, 3);
//Time mytime1 = mytime0;
//mytime1.print();
func();
return 0;
}
最终输出：
ordinary function is called //调用函数
constructor2 is called //构造tmptime变量
copy constructor is called //产生XXXX临时变量并复制tmptime
destructor is called //tmptime
destructor is called //XXXX
当func()函数执行到return时，会产生以下几个重要步骤：
(1) 先会产生一个临时变量，就叫XXXX吧。
(2) 然后调用拷贝构造函数把tmptime的值给XXXX。这两个步骤有点像：Time XXXX(tmptime);
(3) 在函数执行到最后先析构tmptime局部变量。
(4) 等func()执行完后再析构掉XXXX对象。
3. 当成员变量为类类型时
在Time类上面，新定义一个Tmpclass类。
“Time.h”：
#include<iostream>
#include<assert.h>
using namespace std;
class Tmpclass {
public:
Tmpclass()
{
cout << "调用了Tmpclass（）构造函数" << endl;
}
Tmpclass(const Tmpclass& tmpclass)
{
cout << "调用了Tmpclass（）拷贝构造函数" << endl;
}
};
class Time {
private:
int Hour;
int Minute;
int Second;
public:
Tmpclass tmpclass; //public
//构造函数列表初始化
Time()
{
cout << "constructor1 is called" << endl;
}
Time(int tmphou, int tmpmin, int tmpsec) :Hour(tmphou), Minute(tmpmin), Second(tmpsec)
{
cout << "constructor2 is called" << endl;
}
//拷贝构造函数
Time(const Time& tmptime)
{
cout << "copy constructor is called" << endl;
}
~Time()
{
cout << "destructor is called" << endl;
}
void print()
{
cout << Hour << ' ' << Minute << ' ' << Second << endl;
}
};
“main.cpp”：
#include<iostream>
#include"Time.h"
using namespace std;
int main()
{
Time mytime;
Time rect1(1, 2, 3);
Time rect2(rect1); //Time rect2 = rect1;
rect2.print();
return 0;
}
最终输出：
调用了Tmpclass（）构造函数 //每需要新建Time变量，就会调用Tmpclass的构造函数（mytime）
constructor1 is called
调用了Tmpclass（）构造函数
constructor2 is called
调用了Tmpclass（）构造函数 //说明只在用Time定义时调用
copy constructor is called
1 2 3
destructor is called
destructor is called
destructor is called
如果将Time的拷贝构造函数注释掉，则为：
调用了Tmpclass（）构造函数
constructor1 is called
调用了Tmpclass（）构造函数
constructor2 is called
调用了Tmpclass（）拷贝构造函数
1 2 3
destructor is called
destructor is called
destructor is called
其实，此时因为类Time的拷贝构造函数已经被注释掉，又因为类类型对象 tmpclass所在的类 Tmpclass存在拷贝构造函数。
所以，此时编译器会合成一个Time类的拷贝构造函数，编译器合成这个拷贝构造函数的目的就是向其中插入能够去调用类Tmpclass拷贝构造函数的代码。
所以在上文自己定义拷贝构造函数时，必须给类中成员逐个赋值（值复制）。
即写为：
//拷贝构造函数
Time(const Time& tmptime) :tmpclass(tmptime.tmpclass), Hour(tmptime.Hour)
{
//Hour = tmptime.Hour; //可以写成初始化列表
Minute = tmptime.Minute;
Second = tmptime.Second;
cout << "copy constructor is called" << endl;
}
4. 普通派生类构造函数的写法
三、浅拷贝与深拷贝
1. 默认拷贝构造函数
很多时候在我们都不知道拷贝构造函数的情况下，传递对象给函数参数或者函数返回对象都能很好的进行，这是因为编译器会给我们自动产生一个拷贝构造函数，这就是“默认拷贝构造函数”。
这个构造函数很简单，仅仅使用“老对象”的数据成员的值对“新对象”的数据成员一一进行赋值，它一般具有以下形式：
Time::Time(const& Time tmptime)
{
Hour = tmptime.Hour;
Minute = tmptime.Minute;
Second = tmptime.Second;
}
当然，以上代码不用我们编写，编译器会为我们自动生成。
但是如果认为这样就可以解决对象的复制问题，那就错了，当类中含有静态数据成员时，默认生成的拷贝构造函数不会拷贝静态数据成员。需要自己手动编写添加。
2. 浅拷贝
所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了，但是一旦对象存在了动态成员，那么浅拷贝就会出问题了。让我们考虑如下一段代码：
“Time.h”：
#include<iostream>
#include<assert.h>
using namespace std;
class Time {
private:
int Hour;
int Minute;
int Second;
int* p;
public:
//构造函数列表初始化
Time()
{
p = new int(100);
cout << "constructor1 is called" << endl;
}
Time(int tmphou, int tmpmin, int tmpsec) :Hour(tmphou), Minute(tmpmin), Second(tmpsec)
{
cout << "constructor2 is called" << endl;
}
~Time()
{
assert(p != NULL);
delete p;
cout << "destructor is called" << endl;
}
void print()
{
cout << Hour << ' ' << Minute << ' ' << Second << endl;
}
};
“main.cpp”：
#include<iostream>
#include"Time.h"
using namespace std;
int main()
{
Time mytime;
Time rect1(1, 2, 3);
Time rect2(rect1); //Time rect2 = rect1;
rect2.print();
return 0;
}
最终输出：
在这段代码运行结束之前，会出现一个运行错误。原因就在于在进行对象复制时，对于动态分配的内容没有进行正确的操作。我们来分析一下：
在运行定义rect1对象后，由于在构造函数中有一个动态分配的语句，因此执行后的内存情况大致如下：
在使用rect1复制rect2时，由于执行的是浅拷贝，只是将成员的值进行赋值，这时 rect1.p = rect2.p，也即这两个指针指向了堆里的同一个空间，如下图所示：
因此，当需要复制的成员变量中存在指针等动态成员时，由于执行的是浅拷贝，只是将成员的值进行赋值，复制的指针与原指针指向了堆里的同一个空间，在销毁对象时，两个对象的析构函数将对同一个内存空间释放两次，这就是错误出现的原因。
我们需要的不是两个p有相同的值，而是两个p指向的空间有相同的值，解决办法就是使用“深拷贝”。
3. 深拷贝
在“深拷贝”的情况下，对于对象中动态成员，就不能仅仅简单地赋值了，而应该重新动态分配空间，如上面的例子就应该按照如下的方式进行处理：
“Time.h”：
#include<iostream>
using namespace std;
class Time {
private:
int Hour;
int Minute;
int Second;
int* p;
public:
//构造函数列表初始化
Time() :
p(new int(100)) //指针变量要处处初始化
{
cout << "constructor1 is called" << endl;
}
Time(int tmphou, int tmpmin, int tmpsec) :
Hour(tmphou),
Minute(tmpmin),
Second(tmpsec),
p(new int(100))
{
cout << "constructor2 is called" << endl;
}
/*const int get_p_value()
{
return *p;
}*/
Time& operator = (const Time& obj)
{
std::cout << "calling Time& operator = (const Time& obj)" << std::endl;
}
//拷贝构造函数
Time(const Time& tmptime) :
Hour(tmptime.Hour),
Minute(tmptime.Minute),
Second(tmptime.Second),
p(new int(*tmptime.p)) //构造函数都可以初始化列表表示
{
cout << "copy constructor is called" << endl;
}
~Time()
{
if (p != nullptr) {
delete p;
p = nullptr;
}
cout << "destructor is called" << endl;
}
void print()
{
cout << Hour << ' ' << Minute << ' ' << Second << endl;
}
};
“main.cpp”：
#include<iostream>
#include"Time.h"
using namespace std;
int main()
{
Time mytime;
Time rect1(1, 2, 3);
Time rect2(rect1); //Time rect2 = rect1;
rect2.print();
return 0;
}
此时，在完成对象的复制后，内存的一个大致情况如下：
此时rect1的p和rect2的p各自指向一段内存空间，但它们指向的空间具有相同的内容，这就是所谓的“深拷贝”。
4. 防止默认拷贝发生
通过对对象复制的分析，我们发现对象的复制大多在进行“值传递”时发生，这里有一个小技巧可以防止按值传递——声明一个私有拷贝构造函数。甚至不必去定义这个拷贝构造函数，这样因为拷贝构造函数是私有的，如果用户试图按值传递或函数返回该类对象，将得到一个编译错误，从而可以避免按值传递或返回对象。
小结：
拷贝有两种：深拷贝，浅拷贝。
当出现类的等号赋值时，会调用拷贝函数，在未定义显示拷贝构造函数的情况下，系统会调用默认的拷贝函数——即浅拷贝，它能够完成成员的一一复制。
当数据成员中没有指针时，浅拷贝是可行的。但当数据成员中有指针时，如果采用简单的浅拷贝，则两类中的两个指针将指向同一个地址，当对象快结束时，会调用两次析构函数，而导致指针悬挂现象。所以，这时，必须采用深拷贝。
深拷贝与浅拷贝的区别就在于深拷贝会在堆内存中另外申请空间来储存数据，从而也就解决了指针悬挂的问题。简而言之，当数据成员中有指针时，必须要用深拷贝。
四、拷贝构造函数的几个细节
1.为什么拷贝构造函数必须是引用传递，不能是值传递？
为了防止递归引用。
当一个对象需要以值方式传递时，编译器会生成代码调用它的拷贝构造函数以生成一个复本。如果类A的拷贝构造函数是以值方式传递一个类A对象作为参数的话，当 需要调用类A的拷贝构造函数时，需要以值方式传进一个A的对象作为实参； 而以值方式传递需要调用类A的拷贝构造函数；结果就是调用类A的拷贝构造函数导 致又一次调用类A的拷贝构造函数，这就是一个无限递归。
2. 拷贝构造函数的作用。
作用就是用来复制对象的，在使用这个对象的实例来初始化这个对象的一个新的实例。
3.参数传递过程到底发生了什么？
将地址传递和值传递统一起来，归根结底还是传递的是"值"(地址也是值，只不过通过它可以找到另一个值)
1、值传递:
对于内置数据类型的传递时，直接赋值拷贝给形参(注意形参是函数内局部变量)；
对于类类型的传递时，需要首先调用该类的拷贝构造函数来初始化形参(局部对象)；
如void foo(class_type obj_local){}, 如果调用foo(obj); 首先class_type obj_local(obj) ,这样就定义了局部变量obj_local供函数内部使用
2、引用传递:
无论对内置类型还是类类型，传递引用或指针最终都是传递的地址值。而地址总是指针类型(属于简单类型), 显然参数传递时，按简单类型的赋值拷贝，而不会有拷贝构造函数的调用(对于类类型).
4.拷贝构造函数里能调用private成员变量吗?
拷贝构造函数其实就是一个特殊的构造函数，操作的还是自己类的成员变量，所以不受private的限制。
5. 以下函数哪个是拷贝构造函数,为什么?
X::X(const X&); //拷贝构造函数
X::X(X);
X::X(X&, int a=1); //拷贝构造函数
X::X(X&, int a=1, int b=2); //拷贝构造函数
解答：
对于一个类X, 如果一个构造函数的第一个参数是下列之一:
a) X&
b) const X&
c) volatile X&
d) const volatile X&
且没有其他参数或其他参数都有默认值,那么这个函数是拷贝构造函数。
6. 一个类中可以存在多于一个的拷贝构造函数吗?
解答：类中可以存在超过一个拷贝构造函数。
class X {
public:
X(const X&); // const 的拷贝构造
X(X&); // 非const的拷贝构造
};
注意：
如果一个类中只存在一个参数为 X& 的拷贝构造函数,那么就不能使用const X或volatile X的对象实行拷贝初始化.
如果一个类中没有定义拷贝构造函数,那么编译器会自动产生一个默认的拷贝构造函数。这个默认的参数可能为 X::X(const X&)或 X::X(X&),由编译器根据上下文决定选择哪一个。
五、C++构造函数以及析构函数的若干面试问题
Q1：构造函数能否重载，析构函数能否重载，为什么？
A1：构造函数可以，析构函数不可以。因为函数重载就是为了让程序区分同名但不同参数的函数，而析构函数压根没有参数。
Q2：析构函数为什么一般情况下要声明为虚函数？
A2：虚函数是实现多态的基础，当我们通过基类的指针是析构子类对象时候，如果不定义成虚函数，那只调用基类的析构函数，子类的析构函数将不会被调用。如果定义为虚函数，则子类父类的析构函数都会被调用。
Q3：什么情况下必须定义拷贝构造函数？
A3：当类的对象用于函数值传递时（值参数，返回类对象），拷贝构造函数会被调用。如果对象复制并非简单的值拷贝，那就必须定义拷贝构造函数。例如大的堆 栈数据拷贝。如果定义了拷贝构造函数，那也必须重载赋值操作符。
感谢以下文章：
https://www.cnblogs.com/alantu2018/p/8459250.html（四、五部分大量引用该文章）
扫一扫
3274
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
