C++学习第十六天：类与对象：浅拷贝与深拷贝（面试常见问题）

费马罗尔拉格朗日柯西……

已于 2022-11-24 10:39:04 修改

阅读量334

点赞数 1

分类专栏： c++进阶学习文章标签： c++ 开发语言

于 2022-11-24 10:37:30 首次发布

本文链接：https://blog.csdn.net/hm_uin/article/details/127978164

版权

c++进阶学习专栏收录该内容

13 篇文章 0 订阅

订阅专栏

（一）、构造函数的分类调用形式：以person类为例

1、拷贝构造函数的语法：person (const person &p)，以引用的方式且不能改变被拷贝者的值

eg: person (const person &p)

{ p.m_age=100;//错误，左值不可修改}

2、括号调用（常用）：person p1

person p1（10）

person p2（p1)

3、显示调用：person p1

person p1=person（10）

person p2=person（p1）

4、隐式调用：person p1

person p1=10相当于person p1=person（10）

person p2=p1

注意：默认构造函数：创建对象时，后面不能加括号。否则会被认为是函数声明。

有参构造函数：显示调用时，等式右边称为匿名对象（临时)，在编译器执行完该行后，系统立即释放，并调用析构函数。拷贝构造函数的显示调用，右边person(p1),相当于person p1。所以不要利用拷贝构造函数初始化匿名对象

（二）、拷贝构造函数的调用时机

1、创建对象时调用拷贝构造函数

2、值传递的时候给自定义函数参数传值时调用拷贝构造函数，为什么在自定义函数中可以改变左值，和上面第一条的说法不一样。那调用的拷贝构造函数是怎么隐形工作的

目前解答：在自定义函数中可以改变左值是因为他是值传递，可以改变形参，实参不受影响。调用拷贝构造函数时，形参是常量引用，所以不能改变左值。程序执行顺序：执行自定义函数，传入实参，先调用拷贝构造函数，创建一个临时对象接收，然后再执行自定义函数体中的语句。

疑问：临时对象的作用是什么，自定义函数形参的操作在内存空间上是相当于对临时对象赋值或者输出吗，但是它们的地址不同欸。倒是实参和拷贝构造函数的形参地址相同。

拷贝构造函数是通过引用传递，而不是值传递，不然就会无限递归拷贝构造函数。

#include<iostream>
using namespace std;
class person
{
public:
	person()
	{
		cout << "调用无参构造函数" << endl;
		m_age = 10;
	}
	person(int age)
	{
		m_age = age;
	   cout << "调用有参构造函数" << endl;
	}
	person(const person& p)
	{
		cout << "调用拷贝构造函数" << endl;
		m_age = p.m_age;
	}
	~person()
	{
		cout << "调用析构函数" << endl;
	}
	int m_age;
	int m_height;
};
void dowork(person p)
{
	cout << p.m_age << endl;
}
void test01()
{
	person p2(18);
	dowork(p2);//调用拷贝构造函数
	cout << p2.m_age << endl;
}

int main()
{
	test01();
}

若将上述代码中一部分代码改成

void dowork(person &p)
{
	cout << p.m_age << endl;
	
}

结果不会调用拷贝构造函数

3、以值方式返回局部对象

#include<iostream>
using namespace std;
class person
{
public:
	person()
	{
		cout << "调用无参构造函数" << endl;
		m_age = 10;
	}
	person(int age)
	{
		m_age = age;
	   cout << "调用有参构造函数" << endl;
	}
	person(const person& p)
	{
		cout << "调用拷贝构造函数" << endl;
		m_age = p.m_age;
	}
	~person()
	{
		cout << "调用析构函数" << endl;
	}
	int m_age;
	int m_height;
};

person dowork2()
{
	person p1;
	cout << (int *) &p1<<endl;
	return p1;//以值方式返回局部变量，但是不会直接返回person p1创建的对象，返回的是拷贝的p1的对象，所以执行这一步的时候会调用
}
void test02()
{
	person p = dowork2();
	cout << (int*)&p << endl;
}

int main()
{
	test02();
}

（三）、构造函数调用规则：

1、在没有定义有参构造函数和拷贝构造函数时，编译器可以调用默认构造函数和拷贝（浅拷贝）构造函数。

2、在定义了有参构造函数，没有定义拷贝构造函数时，编译器按定义格式调用有参构造函数，以调用默认构造函数和拷贝（浅拷贝）构造函数。

3、在定义了有参构造函数和拷贝构造函数时，编译器按定义格式调用有参和拷贝构造函数。

总结：有参不可不定义，无参和拷贝可以不定义也可以调用（只是拷贝是浅拷贝），有参、拷贝定义后按定义规则调用。

一、概念

浅拷贝：系统默认，简单赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝的操作

（一）、浅拷贝

#include<iostream>
using namespace std;
class person
{
public:
	person()
	{
		cout << "调用无参构造函数" << endl;
	}
	person(int age)
	{
		m_age = age;
		cout << "调用有参构造函数" << endl;
	}
	~person()
	{
		cout << "调用析构函数" << endl;
	}
	int m_age;
	int m_height;
};
void test01()
{
	person p1(10);
	cout << "p1的年龄为：" << p1.m_age << endl;
	person p2(p1);
	cout << "p2的年龄为：" << p2.m_age << endl;
}

int main()
{
	test01();
}

上述代码没有写拷贝构造函数，编译器默认浅拷贝，给成员属性赋值。

成员属性是指针类型时，依旧用浅拷贝的情况：

#include<iostream>
using namespace std;
class person
{
public:
	person()
	{
		cout << "调用无参构造函数" << endl;
	}
	person(int age,int height)
	{
		m_age = age;
		m_height = new int(height);//2、用new在堆区为传入参数开辟内存，返回地址用m_height接收，堆区开辟的空间由程序员自己释放
	    cout << "调用有参构造函数" << endl;
	}
	person(const person& p)
	{
		cout << "调用拷贝构造函数" << endl;
		m_age = p.m_age;
		m_height = p.m_height;
	}
	~person()
	{
		cout << "调用析构函数" << endl;
	}
	int m_age;
	int * m_height;//1、用指针的方式定义身高
};
void test()
{
	person p1(18, 160);
	cout << "年龄：" << p1.m_age << " " << "身高：" << *p1.m_height << endl;//3、解引用的方式输出*p1.m_height
	person p2(p1);//无delete释放自己开辟内存空间的拷贝构造函数
	cout << "年龄：" << p2.m_age << " " << "身高：" << *p2.m_height << endl;
}

int main()
{
	test();
}

若用delete（写在析构函数中）释放堆区数据（浅拷贝中）原理，代码如下：

上述代码在析构函数中加入如下，会发现代码崩掉

~person()
	{
		cout << "调用析构函数" << endl;
		if (m_height != NULL)
		{
			delete m_height;
			m_height = NULL;
		}
	}
	int m_age;

（二）、深拷贝解决上述问题

原理：

那么就需要修改拷贝构造函数

原来默认：

person(const person& p)
	{
		cout << "调用拷贝构造函数" << endl;
		m_age = p.m_age;//没有问题
		m_height = p.m_height;//编译器默认实现的就是这行代码
	}

修改后：

person(const person& p)
	{
		cout << "调用拷贝构造函数" << endl;
		m_age = p.m_age;//没有问题
		//m_height = p.m_height;//编译器默认实现的就是这行代码
	//深拷贝操作，重新在堆区开辟一块内存
		m_height = new int(*p.m_height);//为p的属性的解引用开辟一个新的空间赋给被拷贝的对象的成员属性（原来是直接将原来的属性逐字节复制到被拷贝对象）
	//地址变了值没变
	}

总结：如果堆区有自己申请的属性，那么要自己写拷贝构造函数，并且要在析构函数中手动释放堆区空间。