一. 什么是拷贝构造函数
首先对于普通类型的对象来说,它们之间的复制是很简单的,例如:
- int a = 100;
- int b = a;
而类对象与普通对象不同,类对象内部结构一般较为复杂,存在各种成员变量。
下面看一个类对象拷贝的简单例子。
- #include <iostream>
- using namespace std;
- class CExample {
- private:
- int a;
- public:
- //构造函数
- CExample(int b)
- { a = b;}
- //一般函数
- void Show ()
- {
- cout<<a<<endl;
- }
- };
- int main()
- {
- CExample A(100);
- CExample B = A; //注意这里的对象初始化要调用拷贝构造函数,而非赋值
- B.Show ();
- return 0;
- }
运行程序,屏幕输出100。从以上代码的运行结果可以看出,系统为对象 B 分配了内存并完成了与对象 A 的复制过程。就类对象而言,相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。
下面举例说明拷贝构造函数的工作过程。
- #include <iostream>
- using namespace std;
- class CExample {
- private:
- int a;
- public:
- //构造函数
- CExample(int b)
- { a = b;}
- //拷贝构造函数
- CExample(const CExample& C)
- {
- a = C.a;
- }
- //一般函数
- void Show ()
- {
- cout<<a<<endl;
- }
- };
- int main()
- {
- CExample A(100);
- CExample B = A; // CExample B(A); 也是一样的
- B.Show ();
- return 0;
- }
CExample(const CExample& C) 就是我们自定义的拷贝构造函数。可见,拷贝构造函数是一种特殊的 构造函数,函数的名称必须和类名称一致,它必须的一个参数是本类型的一个引用变量 。
二. 拷贝构造函数的调用时机
在C++中,下面三种对象需要调用拷贝构造函数!
1. 对象以值传递的方式传入函数参数
- class CExample
- {
- private:
- int a;
- public:
- //构造函数
- CExample(int b)
- {
- a = b;
- cout<<"creat: "<<a<<endl;
- }
- //拷贝构造
- CExample(const CExample& C)
- {
- a = C.a;
- cout<<"copy"<<endl;
- }
- //析构函数
- ~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;
- }
调用g_Fun()时,会产生以下几个重要步骤:
(1).test对象传入形参时,会先会产生一个临时变量,就叫 C 吧。
(2).然后调用拷贝构造函数把test的值给C。 整个这两个步骤有点像:CExample C(test);
(3).等g_Fun()执行完后, 析构掉 C 对象。
2. 对象以值传递的方式从函数返回
- class CExample
- {
- private:
- int a;
- public:
- //构造函数
- CExample(int b)
- {
- a = b;
- }
- //拷贝构造
- CExample(const CExample& C)
- {
- a = C.a;
- cout<<"copy"<<endl;
- }
- void Show ()
- {
- cout<<a<<endl;
- }
- };
- //全局函数
- CExample g_Fun()
- {
- CExample temp(0);
- return temp;
- }
- int main()
- {
- g_Fun();
- return 0;
- }
当g_Fun()函数执行到return时,会产生以下几个重要步骤:
(1). 先会产生一个临时变量,就叫XXXX吧。
(2). 然后调用拷贝构造函数把temp的值给XXXX。整个这两个步骤有点像:CExample XXXX(temp);
(3). 在函数执行到最后先析构temp局部变量。
(4). 等g_Fun()执行完后再析构掉XXXX对象。
3. 对象需要通过另外一个对象进行初始化;
- CExample A(100);
- CExample B = A;
- // CExample B(A);
后两句都会调用拷贝构造函数。
三. 浅拷贝和深拷贝
1. 默认拷贝构造函数
很多时候在我们都不知道拷贝构造函数的情况下,传递对象给函数参数或者函数返回对象都能很好的进行,这是因为编译器会给我们自动产生一个拷贝构造函数,这就是“默认拷贝构造函数”,这个构造函数很简单,仅仅使用“老对象”的数据成员的值对“新对象”的数据成员一一进行赋值,它一般具有以下形式:
- Rect::Rect(const Rect& r)
- {
- width = r.width;
- height = r.height;
- }
当然,以上代码不用我们编写,编译器会为我们自动生成。但是如果认为这样就可以解决对象 的复制问题,那就错了,让我们来考虑以下一段代码:
- class Rect
- {
- public:
- Rect() // 构造函数,计数器加1
- {
- count++;
- }
- ~Rect() // 析构函数,计数器减1
- {
- 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); // 使用rect1复制rect2,此时应该有两个对象
- cout<<"The count of Rect: "<<Rect::getCount()<<endl;
- return 0;
- }
这段代码对前面的类,加入了一个静态成员,目的是进行计数。在主函数中,首先创建对象rect1,输出此时的对象个数,然后使用rect1复制出对象rect2,再输出此时的对象个数,按照理解,此时应该有两个对象存在,但实际程序运行时,输出的都是1,反应出只有1个对象。此外,在销毁对象时,由于会调用销毁两个对象,类的析构函数会调用两次,此时的计数器将变为负数。
说白了,就是拷贝构造函数没有处理静态数据成员。
出现这些问题最根本就在于在复制对象时,计数器没有递增,我们重新编写拷贝构造函数,如下:
- class Rect
- {
- public:
- Rect() // 构造函数,计数器加1
- {
- count++;
- }
- Rect(const Rect& r) // 拷贝构造函数
- {
- width = r.width;
- height = r.height;
- count++; // 计数器加1
- }
- ~Rect() // 析构函数,计数器减1
- {
- count--;
- }
- static int getCount() // 返回计数器的值
- {
- return count;
- }
- private:
- int width;
- int height;
- static int count; // 一静态成员做为计数器
- };
2. 浅拷贝
所谓浅拷贝,指的是在对象复制时,只对对象中的数据成员进行简单的赋值,默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了,但是一旦对象存在了动态成员,那么浅拷贝就会出问题了,让我们考虑如下一段代码:
- class Rect
- {
- public:
- Rect() // 构造函数,p指向堆中分配的一空间
- {
- p = new int(100);
- }
- ~Rect() // 析构函数,释放动态分配的空间
- {
- if(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指向的空间有相同的值,解决办法就是使用“深拷贝”。
3. 深拷贝
在“深拷贝”的情况下,对于对象中动态成员,就不能仅仅简单地赋值了,而应该重新动态分配空间,如上面的例子就应该按照如下的方式进行处理:
- class Rect
- {
- public:
- Rect() // 构造函数,p指向堆中分配的一空间
- {
- p = new int(100);
- }
- Rect(const Rect& r)
- {
- width = r.width;
- height = r.height;
- p = new int; // 为新对象重新动态分配空间
- *p = *(r.p);
- }
- ~Rect() // 析构函数,释放动态分配的空间
- {
- if(p != NULL)
- {
- delete p;
- }
- }
- private:
- int width;
- int height;
- int *p; // 一指针成员
- };
此时,在完成对象的复制后,内存的一个大致情况如下:
此时rect1的p和rect2的p各自指向一段内存空间,但它们指向的空间具有相同的内容,这就是所谓的“深拷贝”。
3. 防止默认拷贝发生
通过对对象复制的分析,我们发现对象的复制大多在进行“值传递”时发生,这里有一个小技巧可以防止按值传递——声明一个私有拷贝构造函数。甚至不必去定义这个拷贝构造函数,这样因为拷贝构造函数是私有的,如果用户试图按值传递或函数返回该类对象,将得到一个编译错误,从而可以避免按值传递或返回对象。
- // 防止按值传递
- 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;
- }
四. 拷贝构造函数的几个细节
1. 拷贝构造函数里能调用private成员变量吗?
解答:这个问题是在网上见的,当时一下子有点晕。其时从名子我们就知道拷贝构造函数其时就是一个特殊的构造函数,操作的还是自己类的成员变量,所以不受private的限制。
2. 以下函数哪个是拷贝构造函数,为什么?
- 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&
且没有其他参数或其他参数都有默认值,那么这个函数是拷贝构造函数.
- X::X(const X&); //是拷贝构造函数
- X::X(X&, int=1); //是拷贝构造函数
- X::X(X&, int a=1, int b=2); //当然也是拷贝构造函数
3. 一个类中可以存在多于一个的拷贝构造函数吗?
解答:类中可以存在超过一个拷贝构造函数。
- class X {
- public:
- X(const X&); // const 的拷贝构造
- X(X&); // 非const的拷贝构造
- };
注意,如果一个类中只存在一个参数为 X& 的拷贝构造函数,那么就不能使用const X或volatile X的 对象实行拷贝初始化.
- class X {
- public:
- X();
- X(X&);
- };
- const X cx;
- X x = cx; // error
如果一个类中没有定义拷贝构造函数,那么编译器会自动产生一个默认的拷贝构造函数。
这个默认的参数可能为 X::X(const X&)或 X::X(X&),由编译器根据上下文决定选择哪一个。 69楼 卿笃军 2014-05-25 08:47发表
![](http://avatar.csdn.net/4/5/6/3_u012339743.jpg)
A(A a){}
值传递传参为什么会编译通不过?
-
Re:
heipacker 2014-06-04 23:11发表
-
-
回复u012339743:这个不是复制构造函数
-
Re:
卿笃军 2014-06-05 22:18发表
-
-
回复fupacker:我只是想问这种传参方式 编译为何通不过。
-
Re:
heipacker 2014-06-06 23:11发表
-
-
回复u012339743:编译不通过是因为A a这里的定义问题,只有在看到一个类的定义的时候才能把一个数据成员声明为这个类型的对象,
但是当一个类的类头被看到时,它就被视为已经被声明了,所以一个类可以用指向自身类型的指针或引用作为数据成员
这里数据成员你也可以认为是一个变量的定义 看看C++ primer-
Re:
卿笃军 2014-06-07 00:25发表
-
-
回复fupacker:这个我明白。就像结构体一样:
struct node
{
struct node next; //错误
};
struct node
{
struct node *next; //正确
};
————————————
但是:
class A
{
public:
A(A a); //错误
void Print(A a){};//正确
};
这个是如何解释?-
Re:
gdouse1093 2014-09-28 22:02发表
-
- 回复u012339743:如果不是引用会造成无限递归, (会无限的调用拷贝构造函数)
-
Re:
heipacker 2014-06-07 13:45发表
-
- 回复u012339743:拷贝构造函数一定要使用引用传递 你查一下就知道了
-
-
-
-
![](http://avatar.csdn.net/5/8/B/3_chz429.jpg)
关于对象以值传递的方式从函数返回会调用拷贝构造函数,怎么在Devc++测试的时候从函数返回不会调用拷贝构造函数,而在Visual Stdio却调用了呢
- #include<iostream>
- using namespace std;
- struct Node
- {
- int a, b;
- Node(int i, int j):a(i), b(j){}
- Node(const Node& a)
- {
- cout << "copy" << endl;
- }
- };
- Node fun()
- {
- Node n = Node(1,2);
- return n;
- }
- int main()
- {
- fun();
- system("pause");
- }
-
34楼
wanhuatong1987 2013-06-14 10:02发表
-
-
- Rect(const Rect& r)
- {
- width = r.width;
- height = r.height;
- p = new int; // 为新对象重新动态分配空间
- *p = *(r.p);
- }
这样写在程序结束的时候调用了两次析构函数,不存在33楼说的内存泄露问题,这是用VS2010调试的结果。
-
33楼
Mr-Simp1e 2013-06-03 15:08发表
-
-
深拷贝这里,
Rect(const Rect& r)
{
width = r.width;
height = r.height;
p = new int; // 为新对象重新动态分配空间
*p = *(r.p);
}
P重新分配了动态空间,但是原来的空间却没有释放掉。这样就造成了内存泄露吧。
Rect(const Rect& r)
{
width = r.width;
height = r.height;
int *pTemp = p; // 将p指针指向的内存地址缓存起来
p = new int; // 为新对象重新动态分配空间
*p = *(r.p);
delete pTemp; // 释放p原来的内存
}
只是探讨,没有其他意思。-
Re:
Atlas 2013-06-18 09:28发表
-
-
这样写的程序中,不会内存泄漏,但是另外一个问题,如果申请空间失败,但之前改变你实例中的部分,因为这里width = r.width; height = r.height; 已经执行了,是不是违反了异常安全性,这个怎么看?
-
Re:
wanhuatong1987 2013-06-14 10:09发表
-
-
回复bboyfeiyu:博友,你这样写的话会出现“ 0xC0000005: Access violation reading location 0xccccccc0.”错误,这是VS2010调试的结果。其实,文中那样写在退出程序的时候会调用两次析构函数,不会存在内存泄漏的问题。如有不对的地方,请指教。
-
Re:
Mr-Simp1e 2013-06-14 12:46发表
-
-
回复wanhuatong1987:gcc倒是不会报错,改成这样应该没有问题。
P重新分配了动态空间,但是原来的空间却没有释放掉。这样就造成了内存泄露吧。
Rect(const Rect& r)
{
width = r.width;
height = r.height;
int *pTemp = p; // 将p指针指向的内存地址缓存起来,局部指针变量
p = new int; // 为新对象重新动态分配空间
*p = *(r.p);
}-
Re:
kkkwjx 2014-09-06 12:35发表
-
-
回复bboyfeiyu:我认为不会出现内存泄露。
首先既然是构造函数,p最初就是一个野值,没有指向分配的内存,所以无需考虑释放原来的内存,直接进行内存分配即可。注意是直接分配不是重新分配。
反而觉得您的代码有问题,delete了一个野值,可能会出现问题。
-
-
-
-
31楼
蛋疼的 2013-04-22 15:20发表
-
-
除非返回值的临时变量是在函数刚进入时先入栈。。
-
Re:
NBHH0329 2014-07-25 16:57发表
-
- 回复u010050719:从汇编上来说确实如此。临时变量XXX生成的汇编语句是更靠前的。
-
-
30楼
蛋疼的 2013-04-22 15:16发表
-
-
(1). 先会产生一个临时变量,就叫XXXX吧。
(2). 然后调用拷贝构造函数把temp的值给XXXX。整个这两个步骤有点像:CExample XXXX(temp);
(3). 在函数执行到最后先析构temp局部变量。
(4). 等g_Fun()执行完后再析构掉XXXX对象。
个人觉得先析构xxxx对象再析构temp局部变量
函数返回值如果大于8字节,就要创建一个临时内存来放临时变量,按照堆栈的先进后出原则,temp应该是先入栈,xxxx这个临时变量(其实只能叫做指针,指向一块存放该类型变量的内存)后入栈,这个指针指向的地址会存放在寄存器中,函数返回时寄存器EAX根据这个地址去找到临时变量的内容,你也许会说那函数返回,该函数的堆栈祯已经销毁,如何返回该临时变量的值,堆栈祯是被销毁了,但是程序不会清空其中的值,临时变量所在内存值依然存在。-
Re:
heipacker 2014-06-06 23:23发表
-
- 回复u010050719:你自己分析的结论也是先析构的temp再析构XXX啊
-
Re:
江浙沪小团队移动外包 2013-10-11 15:34发表
-
- 回复u010050719:本人亲测的确是先析构掉了函数内的局部变量,然后程序执行完后才析构函数返回时调用拷贝构造函数产生的临时对象。
-
Re:
夏雪冬日 2013-08-10 14:46发表
-
- 回复u010050719:分析的到位。我的观点跟你一样!
-
-
17楼
fly2sky 2013-02-21 23:11发表
-
- 2中的问题又验证了一下,在vc下就会调用拷贝构造函数,在linux下用g++编译则不会调用拷贝构造函数,看来和编译器有关,文章很给力,学习了
-
16楼
fly2sky 2013-02-21 22:48发表
-
- 2. 对象以值传递的方式从函数返回 这个给的例子验证了一下,并没有调用到拷贝构造函数,请博主试一下