在这一篇文章当中，我们会学习一下C++当中的复制以及复制构造函数，当然，还会用一个相对比较完整的代码类作为例子。这也是我们第一次写一个相对比较长的和完整的代码。

对于C++来说，理解复制是非常重要的，因为整个C++变成可以说就是对于内存的操作，而复制就是有关于将内存中的数据重新复制一份并粘贴到一个新的内存地址上的过程。但是我们需要注意的是，复制这件事情是非常花费时间和内存的，所以在没有必要的情况下，我们应该尽可能避免不必要的复制，尤其是如果我们只是读取，或者说是希望能够影响输入的变量本身的情况下，就更不希望是复制了。

通常来讲，我们的赋值过程都是把变量赋值了一遍，比如下面最简单的：

int a = 2;
int b = a;

只要我们这么写，那么a和b就是完全两个不同的变量了，有着不同的存储地址，修改其中一个不会对另一个造成任何影响。但是如果我们复制粘贴的对象是指针的话：

int* ptr = &a;
int* ptr2 = ptr;

ptr2和ptr也是两个不同的指针变量，它们也有着不同的地址，但是问题在于，它们指向了相同的一块内存。所以如果我们对其中一个指针指向的内容进行了修改，那么另一个指针指向的内容也会被影响，因为这是相同的内容；但是如果我们单纯修改指针本身，那么不会影响另一个指针的值。

引用是最特殊的，因为我们只要修改了引用，就一定会影响到被引用对象，所以引用不存在复制之后与你无瓜的情况。

这篇文章当中，我们选择以string类为例，我们自己动手写自己的string类，然后看看我们需要什么，会出现什么问题。

首先我们需要原始的char指针和统计string长度的size变量：

#include<iostream>
#include<memory>
#include<cstdlib>


class String {
private:
	char* m_String;
	unsigned int m_Size;
}

同时，我们需要一个构造函数，在我们给它输入一个const char*类型变量的时候，可以做到对这个对象进行赋值，方式是C风格的拷贝内存函数memcpy，同时存储它的长度信息。需要注意的一点是，因为我们需要尾部有一个终止符，所以我们需要留出更长的一段，然后为它手动添加终止符，不然的话我们就又会面临各种烫烫烫了。

String(const char* str) {
	m_Size = strlen(str);
	m_String = new char[m_Size + 1];
	memcpy(m_String, str, m_Size);
	m_String[m_Size] = 0;
}

因为我们将长度和字符串信息设置为private，所以可以考虑添加两个Get函数，虽然其实没啥必要

unsigned int GetLen() const {
	return m_Size;
}
char* GetString() const {
	return m_String;
}

为了方便我们输出结果，所以我们需要重载一下<<运算符：

static std::ostream& operator<<(std::ostream& stream, String str) {
	std::cout << str.m_String;
	return stream;
}

当然我们这么写的话，涉及到了使用private变量，所以我们需要声明一下这个函数是类String的友元函数，方式就是直接加一个前缀friend，然后声明在类的定义里面。

friend static std::ostream& operator<<(std::ostream& stream, String str);

或者我们可以直接使用GetString函数，也没有什么问题。

好了，现在我们可以用一个字符串实例化这个类的对象并进行输出啦：

String name = "Cherno";
std::cout << name << std::endl;

还有，如果我们想要通过查找序号来修改字符串当中的某一个值，那么就可以采用这样的方式，重载[]，与此同时我们还可以做一个越界检查：

char& operator[](unsigned int m) const {
	if (m > m_Size - 1)
		std::cout << "The index exceed the max length!";
	abort();
	return m_String[m];
}

好了，我们可以进行如下修改且不会出错了：

name[2] = 'a';
std::cout << name << std::endl;

那么接下来，我们可以尝试一下赋值操作，将一个String类对象赋值到另一个String类对象上去看看会发生什么：

String name = "Cherno";
String other = name;
std::cout << name << std::endl;
std::cout << other << std::endl;

看起来是没有任何问题的。但是如果我们进入到调试模式，会发现这样一个问题：

name和other两个本应没有关系的变量，居然成员m_String拥有着完全相同的地址！这个看起来是很不符合常理的，因为这意味着一旦其中一个的内存被释放，另一个也会马上被释放。如果我们写一个析构函数，这一点会体现得更加明显。

这是因为什么？因为我们在复制的时候，确实是复制了全部的类当中的变量，包括指针，也就意味着两个实例化的对象当中指针所指向的内容是完全一样的！那么当我们在删除的时候，会将同一块内存释放两次，从而造成错误。

那么如何解决这个问题？实际上我们需要分配一块新的内存，然后指向这块新的内存，这样才会不至于出现刚才这种错误。这种方式我们被称为深拷贝，这样才能复制整个变量，而为了实现深拷贝，我们需要使用的是拷贝构造函数，在我们使用一个变量去赋值给另一个变量的时候，就会被调用。而我们刚才出现错误的拷贝方式就被称为浅拷贝。

拷贝构造函数的形式是什么样的？如下所示，这个函数会在赋值的时候被调用：

String(const String& other){
}

而我们之前做的事情相当于在里面这样写：

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

如果我们不想允许拷贝，可以写成

String(const String& other) = delete;

想要真正的进行深拷贝，我们需要这样重新分配内存并用指针指向这部分内存：

String(const String& other)
    :m_Size(other.GetLen()){
	m_String = new char[m_Size + 1];
	memcpy(m_String, other.GetString(), m_Size);
	m_String[m_Size] = 0;
}

这样我们再进行拷贝的时候，进入调试模式就会看到m_String指向的地址不同了：

于是我们整个类的定义就如下所示了：

#include<iostream>
#include<memory>
#include<cstdlib>


class String {
private:
	char* m_String;
	unsigned int m_Size;
public:
	String(const char* str) {
		m_Size = strlen(str);
		m_String = new char[m_Size + 1];
		memcpy(m_String, str, m_Size);
		m_String[m_Size] = 0;
	}
	~String() {
		delete[] m_String;
		m_Size = 0;
	}
	String(const String& other)
	    :m_Size(other.GetLen()){
		m_String = new char[m_Size + 1];
		memcpy(m_String, other.GetString(), m_Size);
		m_String[m_Size] = 0;
	}
	unsigned int GetLen() const {
		return m_Size;
	}
	char* GetString() const {
		return m_String;
	}
	char& operator[](unsigned int m) const {
		if (m > m_Size - 1)
			std::cout << "The index exceed the max length!";
		abort();
		return m_String[m];
	}

	friend static std::ostream& operator<<(std::ostream& stream, const String& str);
};

static std::ostream& operator<<(std::ostream& stream, const String& str) {
	std::cout << str.m_String;
	return stream;
}


int main() {
	String name = "Cherno";
	String other = name;
	std::cout << name << std::endl;
	std::cout << other << std::endl;

	std::cin.get();
}

但是我们需要指出的一点是，如果函数参数只是变量本身，那么我们在调用函数的时候也会发生拷贝，而这在很多时候是会非常浪费时间的，因为我们在不想改变变量的值的情况下，复制是没有任何意义的，只会导致效率的降低。所以always pass value by const reference。即使我们想要复制，我们也可以在函数当中自己手动定义一个新变量然后进行复制。