掘根宝典之C++深复制与浅复制（复制构造函数，默认复制构造函数）

news2024/10/6 12:23:18

到目前为止我们已经学了构造函数，默认构造函数，析构函数：http://t.csdnimg.cn/EOQxx

转换函数，转换构造函数：http://t.csdnimg.cn/kiHo6

友元函数：http://t.csdnimg.cn/To8Tj

接下来我们来学习一个新函数——复制构造函数

复制构造函数

复制构造函数用于将一个对象复制到新创建的对象中。也就是说它用于初始化过程中（包括按值传递参数），而不是常规的赋值过程中

类的复制构造函数原型通常如下：

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();

}

这便是深度复制了