⼀. 什么是拷贝构造函数
转⾃百度定义：拷贝构造函数，⼜称复制构造函数，是⼀种特殊的构造函数，它由编译器调⽤来完成⼀些基于同⼀类的其他对象的构建及初始化。其形参必须是引⽤，但并不限制为const，⼀般普遍的会加上const限制。此函数经常⽤在函数调⽤时⽤户定义类型的值传递及返回。拷贝构造函数要调⽤基类的拷贝构造函数和成员函数。如果可以的话，它将⽤常量⽅式调⽤，另外，也可以⽤⾮常量⽅式调⽤。 对于普通类型的对象来说，它们之间的复制是很简单的，例如：
int a =100;
int b = a;
⽽类对象与普通对象不同，类对象内部结构⼀般较为复杂，存在各种成员变量。
下⾯看⼀个类对象拷贝的简单例⼦。
#include<iostream>
观澜湖世界明星赛
using namespace std;
class CExample
{
private:
int a;
public:
//构造函数
CExample(int b)
{
a=b;
printf("constructor is called\n");
}
//拷贝构造函数
CExample(const CExample & c)
{
a=c.a;
printf("copy constructor is called\n");
}
//析构函数
~CExample()
{
cout<<"destructor is called\n";
}
void Show()
{
cout<<a<<endl;
}
};
int main()
{
CExample A(100);
CExample B=A;
B.Show();
return0;
}
程序运⾏结果如下：
constructor is called
copy constructor is called
100
destructor is called
destructor is called
运⾏程序，屏幕输出100。从以上代码的运⾏结果可以看出，系统为对象 B 分配了内存并完成了与对象 A 的复制过程。就类对象⽽⾔，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。
CExample(const CExample& C) 就是我们⾃定义的拷贝构造函数。可见，拷贝构造函数是⼀种特殊的构造函数，函数的名称必须和类名称⼀致，它必须的⼀个参数是本类型的⼀个引⽤变量。
⼆. 使⽤条件
在C++中，下⾯三种对象需要调⽤拷贝构造函数（有时也称“复制构造函数”）：
1. ⼀个对象作为函数参数，以值传递的⽅式传⼊函数体；
void g_fun(CExample c)
{
cout<<"g_func"<<endl;
}
int main()
{
g_fun(A);
}
2. ⼀个对象作为函数返回值，以值传递的⽅式从函数返回；
CExample g_fun()
{
CExample temp(0);
安阳市三官庙小学
return temp;
}
int main()
{
g_fun();租借法案
}
3. ⼀个对象⽤于给另外⼀个对象进⾏初始化（常称为赋值初始化）；
CExample A(100);
CExample B=A;
如果在前两种情况不使⽤拷贝构造函数的时候，就会导致⼀个指针指向已经被删除的内存空间。对于第三种情况来说，初始化和赋值的不同含义是拷贝构造函数调⽤的原因。事实上，拷贝构造函数是由普通构造函数和赋值操作符共同实现的。描述拷贝构造函数和赋值运算符的异同的参考资料有很多。
尿苷三、浅拷贝与深拷贝
1. 默认拷贝构造函数
很多时候在我们都不知道拷贝构造函数的情况下，传递对象给函数参数或者函数返回对象都能很好的进⾏，这是因为编译器会给我们⾃动产⽣⼀个拷贝构造函数，这就是“默认拷贝构造函数”，这个构造函数很简单，仅仅使⽤“⽼对象”的数据成员的值对“新对象”的数据成员⼀⼀进⾏赋值，它⼀般具有以下形式：
Rect::Rect(const Rect& r)
{
width=r.width;
height=r.height;
}
当然，以上代码不⽤我们编写，编译器会为我们⾃动⽣成。但是如果认为这样就可以解决对象的复制问题，那就错了，让我们来考虑以下⼀段代码：
public:
Rect()
{
count++;
}
~Rect()
{
count--;
}
static int getCount()
{
return count;
}
香山帮private:
int width;
int height;
static int count;
};
int Rect::count=0;玻璃工艺学
int main()
{
Rect rect1;
cout<<"The count of Rect:"<<Rect::getCount()<<endl;
Rect rect2(rect1);
cout<<"The count of Rect:"<<Rect::getCount()<<endl;
return0;
}
这段代码对前⾯的类，加⼊了⼀个静态成员，⽬的是进⾏计数。在主函数中，⾸先创建对象rect1，输出此时的对象个数，然后使⽤rect1复制出对象rect2，再输出此时的对象个数，按照理解，此时应该有两个对象存在，但实际程序运⾏时，结果如下：
The count of Rect:1
The count of Rect:1
此外，在销毁对象时，由于会调⽤销毁两个对象，类的析构函数会调⽤两次，此时的计数器将变为负数。
说⽩了，就是拷贝构造函数没有处理静态数据成员。
出现这些问题最根本就在于在复制对象时，计数器没有递增，我们重新编写拷贝构造函数，如下：
public:
Rect()
{
count++;
}
Rect(const Rect& r)
{
width=r.width;
height=r.height;
count++;
}
~Rect()
{
count--;
}
static int getCount()
{
return count;
}
private:
int width;
int height;
static int count;
};
int Rect::count=0;
int main()
{
Rect rect1;
cout<<"The count of Rect:"<<Rect::getCount()<<endl;
Rect rect2(rect1);
cout<<"The count of Rect:"<<Rect::getCount()<<endl;
return0;
}
此时的输出与我们期望的⼀致，结果如下：
The count of Rect:1
The count of Rect:2
2. 浅拷贝
所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进⾏简单的赋值，默认拷贝构造函数执⾏的也是浅拷贝。⼤多情况下“浅拷贝”已经能很好地⼯作了，但是⼀旦对象存在了动态成员，那么浅拷贝就会出问题了，让我们考虑如下⼀段代码：
#include<assert.h>
using namespace std;
class Rect
{
public:
Rect()
{
p=new int(100);
}
~Rect()
{
assert(p!=NULL);
delete p;
}
private:
int width;
int height;
int*p;
};
int main()
{
Rect rect1;
Rect rect2(rect1);
return0;
}
在这段代码运⾏结束之前，会出现⼀个运⾏错误。原因就在于在进⾏对象复制时，对于动态分配的内容没有进⾏正确的操作。我们来分析⼀下：
在运⾏定义rect1对象后，由于在构造函数中有⼀个动态分配的语句，因此执⾏后的内存情况⼤致如下：
在使⽤rect1复制rect2时，由于执⾏的是浅拷贝，只是将成员的值进⾏赋值，这时 rect1.p = rect2.p，也即这两个指针指向了堆⾥的同⼀个空间，如下图所⽰：
当然，这不是我们所期望的结果，在销毁对象时，两个对象的析构函数将对同⼀个内存空间释放两次，这就是错误出现的原因。我们需要的不是两个p有相同的值，⽽是两个p指向的空间有相同的值，解决办法就是使⽤“深拷贝”。
3. 深拷贝
在“深拷贝”的情况下，对于对象中动态成员，就不能仅仅简单地赋值了，⽽应该重新动态分配空间，如上⾯的例⼦就应该按照如下的⽅式进⾏处理：
豫公网安备41160202000603
站长QQ:729038198
关于我们
投诉建议