到目前为止我们已经学了构造函数,默认构造函数,析构函数:
转换函数,转换构造函数:
友元函数:
接下来我们来学习一个新函数——复制构造函数
复制构造函数
复制构造函数用于将一个对象复制到新创建的对象中。也就是说它用于初始化过程中(包括按值传递参数),而不是常规的赋值过程中
类的复制构造函数原型通常如下:
class name(const class name&);
什么时候调用复制构造函数
新建一个对象并将其初始化为同类现有对象时,复制构造函数将被调用。
这在很多情况下都可能会发生,最常见的情况是将新对象显式的初始化为现有对象。
比如下面这些情况
#include<iostream>
using namespace std;
class AA
{
private:
int a_;
public:
AA(const AA& t)
{
a_ = t.a_;
}
AA(int a)
{
a_ = a;
}
};
int main()
{
AA t ={2} ;
AA w = t;//下面4句都将调用复制构造函数
AA e = AA(t);
AA* r = new AA(t);
AA y(t);
}
还有一些情况是每当程序生成了程序副本时,编译器都将使用复制构造函数。
准确的说是当函数按值传递对象和函数返回对象时,都将使用复制构造函数。
我们举个例子
#include<iostream>
using namespace std;
class AA
{
private:
int a_;
public:
AA(const AA& t)
{
cout << "调用了复制构造函数" << endl;
a_ = t.a_;
}
AA(int a)
{
a_ = a;
}
void A(AA a)
{
cout << a.a_ << endl;
}
AA B(AA&t)
{
AA w(t);
return w;
}
};
int main()
{
AA e = { 3 };
AA r = { 9 };
e.A(r);
AA t = e.B(r);
}
结果是
调用了复制构造函数
9
调用了复制构造函数
默认的复制构造函数
如果我们没有提供复制构造函数,编译器就会自动提供一个复制构造函数,这个复制构造函数也叫默认复制构造函数。默认的复制构造函数逐个复制非静态成员(成员复制也叫浅复制)
我们可以看个例子
#include<iostream>
using namespace std;
class AA
{
private:
int a_;
public:
AA(int a)
{
a_ = a;
}
};
int main()
{
AA a = { 9 };
AA t = a;
/*与下面的语句等效
AA t;
t.a_=a.a_;
*/
}
浅复制
默认复制构造函数的浅复制
我们先来看这么一个例子
#include<iostream>
using namespace std;
class AA
{
private:
int*a_;
public:
AA(int a)
{
a_ = new int(a);
}
void A()
{
cout << *a_ << endl;
}
};
int main()
{
AA a(9);
a.A();//结果是9
AA t = a;
t.A();//结果是9
}
结果是
9
9
可能现在你还没发现什么异样,那我们再看下面这个例子
#include<iostream>
using namespace std;
class AA
{
private:
int*a_;
public:
AA(int a)
{
a_ = new int(a);
}
void A()
{
cout << *a_ << endl;
}
void shan()
{
delete a_;
}
};
int main()
{
AA a(9);
a.A();
AA t = a;
t.A();
a.shan();
t.A();
}
结果是
9
9
-572662307
我们会发现,啊嘞?第三行怎么是一堆乱码。这是什么情况呢?
原来啊,上面这个情况在对对象进行复制时,只简单地复制对象的成员变量值,而没有复制对象内部的动态分配的资源,这个叫浅复制
这是因为浅复制只复制了指针的值,而没有复制指针所指向的内存。因此,两个对象的a_成员变量指向同一块内存,修改任何一个对象的a_值都会影响到另一个对象。
自定义复制构造函数的浅复制
不用以为我们定义了复制构造函数,进行的复制就不叫浅复制了。实际上,下面这种也叫浅复制。
上例子
#include<iostream>
using namespace std;
class AA
{
private:
int*a_;
public:
AA(int a)
{
a_ = new int(a);
}
AA(const AA&a)
{
a_ = a.a_;
}
void A()
{
cout << *a_ << endl;
}
void shan()
{
delete a_;
}
};
int main()
{
AA a (9);
a.A();
AA t = a;
t.A();
a.shan();
t.A();
}
结果是
9
9
-572662307
惊奇的发现和上面的情况是一样的,这是因为我们定义的复制构造函数也仅仅是复制指针的值罢了,没有开辟新的内存块
浅复制的用武之地
浅复制在某些情况下可能是合适的,例如对于只包含基本类型成员变量的简单对象。但是对于包含动态分配的资源或指针成员变量的对象来说,浅复制可能会导致错误或内存泄漏。在这种情况下,应该使用深复制来保证每个对象都有独立的资源副本。
深复制
解决上面这种类设计中的问题的方法是进行深度复制。也就是说复制构造函数应当复制值并将副本的地址赋给a_成员,而不仅仅是复制值地址。
我们直说可能有点难懂,看个图就知道了
必须定义复制构造函数的原因是一些类成员是使用new初始化的,指向数据的指针,而不是数据本身。
什么时候使用深复制?什么时候用浅复制?
如果类里包含了使用new初始化的指针成员,应当定义一个复制构造函数,以复制指向的数据,而不是指针,这被称作深度复制。浅复制仅浅浅的复制指针信息,而不会深入复制new出来的那块内存。
实现深复制
实现深复制就必须自己定义一个会另外开辟内存的复制构造函数,而不是简单的逐成员复制
我们看个例子
#include<iostream>
using namespace std;
class AA
{
private:
int*a_;
public:
AA(int a)
{
a_ = new int(a);
}
AA(const AA&a)
{
int* w = new int(*a.a_);//深度复制的体现
a_ = w;
}
void A()
{
cout << *a_ << endl;
}
void shan()
{
delete a_;
}
};
int main()
{
AA a = { 9 };
a.A();
AA t = a;
t.A();
a.shan();
t.A();
}
这便是深度复制了
赋值运算符里的浅复制
我们得先知道,C++允许把一个对象赋值给另一个同类对象
初始化的时候总是会调用复制构造函数,而使用=运算符时也允许调用赋值运算符
将已有对象赋给另一个对象时,将采用重载的赋值运算符
初始化时不一定会使用赋值运算符
使用赋值运算符的情况和那个隐式复制构造函数一样,都是浅复制的问题。文章来源:https://www.toymoban.com/news/detail-825594.html
我们可以使用友元函数来重载运算符=,使其成为深度赋值文章来源地址https://www.toymoban.com/news/detail-825594.html
到了这里,关于掘根宝典之C++深复制与浅复制(复制构造函数,默认复制构造函数)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!