构造函数是一个初始化类对象的函数,即使不显示调用,编译器也会隐式调用构造函数初始化类对象。同样的,拷贝构造函数是一种特殊的构造函数,目的也是初始化类对象,同样在不声明的情况下也会隐式调用该函数。而隐式调用拷贝构造函数的时候,我们称之为“浅拷贝”。但是,请注意一点,并不是说显示调用就是“深拷贝”,而是如果要深拷贝一定要显示调用。
拷贝构造函数是一种特殊的构造函数,它在创建对象时,是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数常用于:
- 通过使用另一个同类型的对象来初始化新创建的对象;
- 复制对象把它作为参数传递给函数;
- 复制对象,并从函数返回这个对象。
如下:
#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;
}
};
void g_fun(CExample c)
{
cout << "g_func" << endl;
}
int main()
{
CExample A(100);
CExample B = A;
B.Show();
g_fun(A);
return 0;
}
我们可以很清楚看到在用对象a给对象b赋值的时候调用了拷贝构造函数。
那么复制对象,并从函数返回这个对象。是怎样调用拷贝构造函数的?
我们在调用g_fun()时,会产生以下几个重要步骤:
(1).A对象传入形参时,会先会产生一个临时变量,就叫 C 吧。
(2).然后调用拷贝构造函数把A的值给C。 整个这两个步骤有点像:CExample C(A);
(3).等g_fun()执行完后, 析构掉 C 对象。
对,就这样调用的。
函数的返回值是类的对象时
CExample g_fun()
{
CExample temp(0);
return temp;
}
int main()
{
g_fun();
return 0;
}
当g_Fun()函数执行到return时,会产生以下几个重要步骤:
(1). 先会产生一个临时变量,就叫q吧。
(2). 然后调用拷贝构造函数把temp的值给q。整个这两个步骤有点像:CExample q(temp);
(3). 在函数执行到最后先析构temp局部变量。
(4). 等g_fun()执行完后再析构掉q对象。
浅拷贝
浅拷贝,指的是在对象复制时,只对对象中的数据成员进行简单的赋值,默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了,但是一旦对象存在了动态成员,那么浅拷贝就会出问题了,让我们考虑如下一段代码:
#include<iostream>
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);
return 0;
}
在这段代码运行结束之前,会出现一个运行错误。原因就在于在进行对象复制时,对于动态分配的内容没有进行正确的操作。我们来分析一下:
在运行定义rect1对象后,由于在构造函数中有一个动态分配的语句,因此执行后的内存情况大致如下:
在使用rect1复制rect2时,由于执行的是浅拷贝,只是将成员的值进行赋值,这时 rect1.p = rect2.p,也即这两个指针指向了堆里的同一个空间,如下图所示:
当然,这不是我们所期望的结果,在销毁对象时,两个对象的析构函数将对同一个内存空间释放两次,这就是错误出现的原因。我们需要的不是两个p有相同的值,而是两个p指向的空间有相同的值,解决办法就是使用“深拷贝”。
深拷贝
在“深拷贝”的情况下,对于对象中动态成员,就不能仅仅简单地赋值了,而应该重新动态分配空间,如上面的例子就应该按照如下的方式进行处理:
#include<iostream>
#include<assert.h>
using namespace std;
class Rect
{
public:
Rect()
{
p=new int(100);
}
Rect(const Rect& r)
{
width=r.width;
height=r.height;
p=new int(100);
*p=*(r.p);
}
~Rect()
{
assert(p!=NULL);
delete p;
}
private:
int width;
int height;
int *p;
};
int main()
{
Rect rect1;
Rect rect2(rect1);
return 0;
}
此时,在完成对象的复制后,内存的一个大致情况如下:
此时rect1的p和rect2的p各自指向一段内存空间,但它们指向的空间具有相同的内容,这就是所谓的“深拷贝”。
那么如何防止默认拷贝发生???
通过对对象复制的分析,我们发现对象的复制大多在进行“值传递”时发生,这里有一个小技巧可以防止按值传递——声明一个私有拷贝构造函数。甚至不必去定义这个拷贝构造函数,这样因为拷贝构造函数是私有的,如果用户试图按值传递或函数返回该类对象,将得到一个编译错误,从而可以避免按值传递或返回对象。
class CExample
{
private:
int a;
public:
//构造函数
CExample(int b)
{
a = b;
cout<<"creat: "<<a<<endl;
}
private:
//拷贝构造函数,只是声明
CExample(const CExample& C);
public:
~CExample()
{
cout<< "delete: "<<a<<endl;
}
void Show ()
{
cout<<a<<endl;
}
};
void g_Fun(CExample C)
{
cout<<"test"<<endl;
}
int main()
{
CExample test(1);
//g_Fun(test); //按值传递将出错
return 0;
}
为什么要用const引用?
const 更多是给程序员的一个限制, 告诉程序员这个变量是只读的。因此为了安全, 一般建议所有的只读变量加const限制以防止程序员犯错。因为复制构造函数是用引用方式传递复制对象,引用方式传递的是地址,因此在构造函数内对该引用的修改会影响源对象。而你在用对象a1构造a2时,自然不希望复制构造函数会改变a1的内容,因此要防止复制构造函数内部修改该引用,所以用const声明。
为什么拷贝构造函数要传引用??
上面 B(A) 中实参 A 赋给形参 C(CExample(const CExample C)) 的时候,也需要拷贝构造函数 C(A) ,这个 C(A) 中的 A 又要赋给形参 C'.......这是不是要无限次的进行拷贝?所以,如果使用引用就可以避免这样的无限循环。