C++——类和对象(中)(2)尚未完结

拷贝构造

概念

在现实生活中,可能存在一个与你一样的自己,我们称其为双胞胎。

那在创建对象时,可否创建一个与已存在对象一某一样的新对象呢?

拷贝构造函数: 只有单个形参该形参是对本类类型对象的引用(一般常用const修饰),在用已存在的类类型对象创建新对象时由编译器自动调用。

特征

拷贝构造函数也是特殊的成员函数,其特征如下
1.拷贝构造函数是构造函数的一个重载形式
2.拷贝构造函数的参数只有一个且必须是类类型对象的引用,使用传值方式编译器直接报错因为会引发无穷递归调用。

3.若未显式定义,编译器会生成默认的拷贝构造函数。
默认的拷贝构造函数对象按内存存储按字节序完成拷贝,这种拷贝叫做浅拷贝,或者值拷贝。

实验日期类——浅拷贝

#include
using namespace std;

class Date
{
public:
	Date(int year = 1, int month=1, int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}


private:
	int _year;
	int _month;
	int _day;
};


int main()
{
	Date d1(2023, 10, 28);
	Date d2(d1);
	d1.Print();
	d2.Print();
}

C++——类和对象(中)(2)尚未完结_第1张图片

在日期类中,我们不写拷贝构造函数时,使用编译器默认生成的可以完成值拷贝/浅拷贝,对于日期类足够使用。 

怎么验证呢?

#include
using namespace std;

class Date
{
public:
	Date(int year = 1, int month=1, int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	~Date()
	{
		cout << "~Date()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

void F(Date d1)
{
	d1.Print();
}
int main()
{
	Date d1(2023, 10, 28);
	F(d1);
}

C++——类和对象(中)(2)尚未完结_第2张图片

C++——类和对象(中)(2)尚未完结_第3张图片

这里析构了两次,第一次析构是d1.print出了作用域要销毁去调用一次析构,第二次是析构是Date d1在程序结束之前自己去调用了一次析构(日期类不需要去析构销毁,这里只是为了下面拷贝构造的引用传参做铺垫)

为了减去第一次析构,使用引用做形参

C++——类和对象(中)(2)尚未完结_第4张图片

C++——类和对象(中)(2)尚未完结_第5张图片

加上引用以后d1.print出了作用域就不会销毁,自然不会去调用掉析构函数,因为Date&d1 就是d1的别名,它会在程序结束之前自己去调用析构(虽说是内存自己回收内置类型,这里调用Date的析构只是为了好理解拷贝构造的引用传参)。 

实验栈类——浅拷贝or深拷贝?

class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		cout << "Stack(size_t capacity = 3)" << endl;
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr)
		{
			perror("malloc fail");
			return;
		}
		_capacity = capacity;
		_top = 0;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};

void f(Stack st1)
{
	//...
}
int main()
{
	Stack st;
	f(st);
}

C++——类和对象(中)(2)尚未完结_第6张图片

为什么会出现程序崩溃?

因为 st1出了作用域会销毁,去调用析构函数,_a被释放了,后面st再去调用析构函数,导致_a再次被释放,共计了释放了两次(_a指向的空间被释放了两次)

C++——类和对象(中)(2)尚未完结_第7张图片

那么怎么解决这个问题呢?

 规定:自定义类型对象拷贝的时候,必须调用一个函数叫拷贝构造。

初始化的时候就去调用拷贝构造

C++——类和对象(中)(2)尚未完结_第8张图片

原因

栈类会造成_a释放两次 而日期类会造成无穷递归

调用拷贝构造 先传参 传值传参 形成新的拷贝构造 形成套娃

因此C++规定用引用传参

C++——类和对象(中)(2)尚未完结_第9张图片

解决(正确使用拷贝构造)

拷贝构造(引用传值) 

#include
using namespace std;

class Date
{
public:
	Date(int year = 1, int month=1, int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	Date(const Date& d)
	{
		_year == d._year;
		_month = d._month;
		_day = d._day;
	}
	~Date()
	{
		cout << "~Date()" << endl;
	}
	
private:
	int _year;
	int _month;
	int _day;
};

int main()
{

	Date d1(2023, 10, 28);
	Date d2(d1);

}

C++——类和对象(中)(2)尚未完结_第10张图片

为了防止拷贝构造赋值传反,加上const修饰, &d(d1)的别名,隐含的this指针指向了d2,引用传值又减少了一次析构(虽然内置类型数据系统自己结束时回收)。

栈—拷贝构造(深拷贝)

class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		cout << "Stack(size_t capacity = 3)" << endl;
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr)
		{
			perror("malloc fail");
			return;
		}
		_capacity = capacity;
		_top = 0;
	}
	深拷贝
	Stack(const Stack&stt)
	{
		cout << "Stack(const Stack&stt)" << endl;
		_a = (int*)malloc(sizeof(int) * stt._capacity);
		if(_a == nullptr)
		{
			perror("malloc fail");
			return;
		}
		_top = stt._top;
		_capacity = stt._capacity;
		memcpy(_a, stt._a, sizeof(int) * stt._top);
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};

int main()
{
	Stack st;
	Stack st1(st);

}

C++——类和对象(中)(2)尚未完结_第11张图片

Stack &stt是st的别名,this指针指向st1,最后把st的数据给st1转过去完成拷贝。

st先进去构造 然后st1进行深拷贝 出了作用域再去调用析构函数 最后程序结束前 st再去调用析构函数。

 

st和st1指向的空间都不同,所以不会出现同一个空间释放两次的问题。拷贝构造完美解决。 

 队列

class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		cout << "Stack(size_t capacity = 3)" << endl;
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr)
		{
			perror("malloc fail");
			return;
		}
		_capacity = capacity;
		_top = 0;
	}
	深拷贝
	Stack(const Stack&stt)
	{
		cout << "Stack(const Stack&stt)" << endl;
		_a = (int*)malloc(sizeof(int) * stt._capacity);
		if(_a == nullptr)
		{
			perror("malloc fail");
			return;
		}
		_top = stt._top;
		_capacity = stt._capacity;
		memcpy(_a, stt._a, sizeof(int) * stt._top);
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
class Myqueque
{
	Stack _push;
	Stack _pop;
	int _sz = 0;
};

int main()
{
	Stack st;
	Stack st1(st);

	Myqueque q1;
	Myqueque q2(q1);

}

 队列又完成了拷贝构造,又是间接调用栈的深拷贝(拷贝构造),真是躺着赢下了游戏。

 栈写了拷贝构造——深拷贝 myqueque就能调用栈的拷贝构造。

总结

日期类不用写拷贝构造 使用编译器默认生成的就可以完成值拷贝——可以完成我们的需要

拷贝构造对内置类型完成默认的拷贝构造——浅拷贝

Date 和 MyQueue 默认生成拷贝就可以用

1、内置类型成员完成值拷贝

 2、自定义类型成员调用这个成员的拷贝构造stack需要自己写拷贝构造,完成深拷贝。

顺序表、链表、二又树等等的类,都需要深拷贝。

注意: 类中如果没有涉及资源申请时,拷贝构造函数是否写都可以;一旦涉及到资源申请时,则拷贝构造函数是一定要写的,否则就是浅拷贝。

为了提高程序效率,一般对象传参时,尽量使用引用类型,返回时根据实际场景,能用引用
尽量使用引用。

你可能感兴趣的:(c++,开发语言,数据结构,c语言)