C++学习笔记：拷贝构造函数、类之间的‘=‘、用const引用的好处【Cherno】

假设我们现在有一个String类和该类的两个实例：A、B；

我们先初始化了A，然后将A拷贝到B上；

我们可以如此：

#include<iostream>
#include<ostream>
#include<algorithm>
#include<string>
using namespace std;

class String {
	char* t;
	int size;
public:

	String(const char* scr) {
		size = strlen(scr);
		t = new char[size + 1];
		memcpy(t, scr, size + 1);
		t[size] = 0;
	}

	~String() {
		delete[] t;
	}
};

int main() {

	String A = "String";
	String B = A;

}

这里我们写了一个构造函数，将一个字符串赋值给String类；

然后将A拷贝到B上，点击运行，我们会发现：

这是为什么呢？

很简单，因为我们直接将A拷贝到B上，所以A和B的t指针指向的是同一块内存，A和B实例的在栈中的，而且B后定义，所以B先调用析构函数，将t指针指向的内存释放，但是当A调用析构函数时发现t指针指向的内存已经被释放了，二次释放是在C++中不允许的；

所以我们知道，如果类中有指针，那么尽量让每个实例指向不同内存；

将怎么做到这件事情之前，我们先了解一下C++给我们提供的默认构造函数：

0：多参数构造函数

这个函数可以开辟空间，也可以按顺序给数据成员赋值；

1：无参默认构造函数【当我们自定义构造函数时这个函数将不会被调用，即被delete掉了】

这个默认构造函数只会开辟空间，不会初始化数据成员；

2：拷贝默认构造函数，【同上】如下：

	String(const String& scr) {
		memcpy(this, &scr, sizeof(scr));
	}

这里一点要注意，构造函数中调用同类时一定要为const引用，否则报错。当然，如果是常规成员函数的话就没有这个限制了；

这个时候如果我们要重载拷贝构造函数，且达到拷贝后两个实例中的指针指向的地址不同，且指针指向的内存内容相同，那么我们只需要简单地改进一下即可：

如下：

	String(const String& scr) 
		:size(scr.size)
	{
		t = new char[size + 1];
		memcpy(t, scr.t, size + 1);
		t[size] = 0;
	}

这样就可以对两个实例进行拷贝操作，且达到我们对指针的要求了； 

这里再补充一个知识点，即类之间的‘=’和基本类型的=之间的差别；

其实没什么差别，如果我们将构造函数【注意：不止拷贝构造函数】设置为explicit，那么我们会发现=它不适用了，因为=是一个隐式调用构造函数的操作，=右边是实参，而基本类型也可以理解为只有一个数据成员的类，也在进行着这样的工作；

用const引用的好处是可以优化程序的速度，且可以增加程序的稳定性；

稳定性这方面其实很好理解，我们不可以在函数中改变const引用的值，所以可以增加稳定性；

那么优化程序的速度这一说是怎么来的呢？

看以下代码：

#include<iostream>
#include<ostream>
#include<algorithm>
#include<string>
using namespace std;

class String {
	char* t;
	int size;
public:

	String(const char* scr) {
		size = strlen(scr);
		t = new char[size + 1];
		memcpy(t, scr, size + 1);
		t[size] = 0;
	}

	String(const String& scr)
		:size(scr.size)
	{
		t = new char[size + 1];
		memcpy(t, scr.t, size + 1);
		t[size] = 0;

		cout << "Copied" << endl;
	}

	~String() {
		delete[] t;
	}

	friend void outString(String);
};

void outString(String scr) {
}

int main() {

	String A = "String";
	String B = A;

	outString(A);
	outString(B);
}

运行结果：

 为什么会有3次copy呢？很简单，A给B赋值一次，A、B分别给outString形参赋值各一次；

这样的话会大大地拖累程序的速度，因为copy是需要时间开销的；

但如果我们给outString函数的形参设置为const引用的话【其实达到这个功能只要引用即可】：

void outString(const String& scr) {
}

运行结果为：

 因为引用它是直接调用实参，所以不用copy