一、拷贝构造函数的性质
定义：
拷贝构造函数是一个成员函数,它用同一个类的一个对象初始化另一个对象。
语法：
-
classname (
const classname &obj) {
-
// body of constructor
-
}
note: 当类中没有定义拷贝构造函数时，编译器默认提供一个拷贝构造函数，简单的进行成员变量的值赋值。
拷贝构造函数的作用：
| 1.从同一类型的另一个对象初始化一个对象。 |
| 2.将对象拷贝作为一个函数的参数。 |
| 3.拷贝一个对象以返回它的函数。 |
拷贝构造函数的意义：
| 浅拷贝 | 拷贝后对象的物理状态相同 |
| 深拷贝 | 拷贝后对象的逻辑状态相同 |
note:编译器提供的拷贝构造函数只进行浅拷贝。
什么时候调用拷贝构造函数：
| 1 .当类对象返回一个值； |
| 2.当类的对象被作为参数通过值传递(到函数)时； |
| 3.当一个类的对象是基于同一个类的另一个对象构造时； |
| 4.当编译器生成一个临时对象时 |
Example1：
-
#include <iostream>
-
-
using
namespace
std;
-
-
class Line {
-
-
public:
-
int getLength(void);
-
Line(
int len);
// 普通构造函数
-
Line(
const Line &obj);
// 拷贝构造函数
-
~Line();
// 析构函数
-
-
private:
-
int *ptr;
-
};
-
-
// 成员函数定义，包括构造函数
-
Line::Line(
int len) {
-
cout <<
"普通构造函数分配指针ptr" <<
endl;
-
-
// 给指针ptr分配内存;
-
ptr =
new
int;
-
*ptr = len;
-
}
-
-
Line::Line(
const Line &obj) {
//obj是用于初始化另一个对象的对象的引用。
-
cout <<
"拷贝构造函数分配指针 ptr." <<
endl;
-
ptr =
new
int;
-
*ptr = *obj.ptr;
// 拷贝值
-
}
-
-
Line::~Line(
void) {
-
cout <<
"释放内存!" <<
endl;
-
delete ptr;
-
}
-
-
int Line::getLength(
void) {
-
return *ptr;
-
}
-
-
void display(Line obj) {
-
cout <<
"line 的长度 : " << obj.getLength() <<
endl;
-
}
-
-
// Main 函数实现
-
int main() {
-
Line line(10);
//调用普通构造函数 Line(int len);
-
-
display(line);
//调用拷贝构造函数 Line(const Line &obj);
-
getchar();
-
return
0;
-
}
编译运行，结果如下：
调用拷贝构造函数的另一种方式 Line line2 = line1; 如下：
-
int main() {
-
-
Line line1(10);
-
-
Line line2 = line1;
// 这也是调用拷贝构造函数
-
-
display(line1);
-
display(line2);
-
-
getchar();
-
return
0;
-
}
二、深拷贝与浅拷贝
Example2：
-
#include <stdio.h>
-
-
class Test
-
{
-
private:
-
int i;
-
int j;
-
int* p;
-
public:
-
int getI()
-
{
-
return i;
-
}
-
int getJ()
-
{
-
return j;
-
}
-
int* getP()
-
{
-
return p;
-
}
-
Test(
const Test& t)
//拷贝构造函数
-
{
-
i = t.i;
-
j = t.j;
-
p =
new
int;
-
-
*p = *t.p;
-
}
-
Test(
int v)
-
{
-
i =
1;
-
j =
2;
-
p =
new
int;
-
-
*p = v;
-
}
-
void free()
-
{
-
delete p;
-
}
-
};
-
-
int main()
-
{
-
Test t1(3);
//调用构造函数Test(int v)
-
Test t2(t1);
//调用拷贝构造函数Test(const Test& t)
-
-
printf(
"t1.i = %d, t1.j = %d, *t1.p = %d\n", t1.getI(), t1.getJ(), t1.getP());
//*t1.p = 4887464
-
printf(
"t2.i = %d, t2.j = %d, *t2.p = %d\n", t2.getI(), t2.getJ(), t2.getP());
//*t2.p = 4887512
-
-
t1.
free();
-
t2.
free();
-
getchar();
-
-
return
0;
-
}
编译运行，
可见，t1 和 t2所指的地址空间是不同的 ，因为t2进行深拷贝。
我们不妨把注释掉下列代码：
-
Test(
const Test& t)
//拷贝构造函数
-
{
-
i = t.i;
-
j = t.j;
-
p =
new
int;
-
-
*p = *t.p;
-
}
然后编译运行：
可见，指针 t1 和 t2的地址相同，说明了t1 和t2 都指向了同一片内存空间。
问题分析：
①浅拷贝：默认构造函数只做浅拷贝。
t1 和t2 都指向了同一片内存空间：
当释放内存地址时，t1 和 t2释放的是同一块内存地址，此时会发生编译错误：
②深拷贝：只能与用户定义的复制构造函数。在用户定义的复制构造函数中,我们确保复制对象指向新的内存位置的指针(或引用)。
可见，Bag2 深拷贝 Bag1，Bag2指向了一片新的内存地址。
Question: 什么时候需要进行深拷贝？
当对象中有成员指代了系统中的资源：
| 1.成员指向了动态内存空间 |
| 2.成员打开了外存中的文件 |
| 3.成员使用了系统中的网络端口 |
一般性原则：
自定义拷贝构造函数，必然需要实现深拷贝！
三、拷贝构造函数 VS 赋值操作符
下面的两个语句哪个调用拷贝构造函数，哪个调用赋值操作符?
-
-
MyClass t1, t2;
-
MyClass t3 = t1;
// ----> (1)
-
t2 = t1;
// -----> (2)
答：
当一个已经初始化的对象从另一个现有对象分配一个新值时,调用赋值操作符：
t2 = t1; //调用赋值操作符, 相当于 "t2.operator=(t1);"
当新对象从现有对象创建时,就会调用拷贝构造函数,作为现有对象的拷贝：
Test t3 = t1; // 调用拷贝构造函数, 相当于"Test t3(t1);"
Test:
-
-
#include<iostream>
-
#include<stdio.h>
-
-
using
namespace
std;
-
-
class Test
-
{
-
public:
-
Test() {}
-
Test(
const Test &t)
-
{
-
cout <<
"调用拷贝构造函数 " <<
endl;
-
}
-
Test&
operator = (
const Test &t)
-
{
-
cout <<
"调用赋值操作符 " <<
endl;
-
}
-
};
-
-
int main()
-
{
-
Test t1, t2;
-
t2 = t1;
//调用赋值操作符
-
Test t3 = t1;
//调用赋值操作符
-
getchar();
-
return
0;
-
}
编译运行，结果如下：
编译运行，结果如下：
<本文完>
Reference:
扫一扫
1165
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
