构造函数，拷贝构造函数，赋值函数，析构函数

每个类都至少有的四个函数，其分别为：

1：构造函数；

2：拷贝构造函数；

3：赋值函数；

4：析构函数；

如果用户不自定义类的这个四个函数，那么C++编译系统会自动生成四个默认的函数；现在分别讲解其功能或是用法：

1：构造函数，这是大家非常熟悉的，一般用来初始化类的数据成员，这里不多讲；

2：拷贝构造函数，声明并用另一个对象初始化时，会用到拷贝构造函数。这里又会分为：浅拷贝和深拷贝；

浅拷贝：默认拷贝构造函数就是浅拷贝，它提供的功能只是简单把类的数据成员进行复制；

深拷贝：其实对于一般的拷贝而言，浅拷贝已足够用，只是在涉及到有指针数据成员的时候，如果只是简单的将类中的数据成员进行复制，那么就会出现很严重的错误。比如：一个类A中有一个数据成员是指针，如果进行浅拷贝，那么在另外一个拷贝类B中，B中指针成员所指的内存空间就会和类A中指针成员所指的内存空间相同，于是麻烦就出在这里，本来是两个毫不相干的类，拥有自己的独立的数据成员，因为指针而使得数据成员不再独立，而相互影响(析构的时候，一个类已经delete掉内存空间，另一个类拿什么内存空间来delete？)。因此，在涉及到有指针成员的时候，要自己写拷贝构造函数。

3：赋值函数，已经实例化了一个对象，用另外一个对象来赋值。注意和拷贝构造函数的区别，调用赋值函数的时候，类对象已经存在(实例化)，而调用拷贝构造函数的时候，类对象是不存在的(没有实例化)。

4：析构函数，析构函数没有返回值，没有函数类型，也没有参数，亦不能重载。析构函数的作用不仅限于释放资源，它还可以被用来执行“用户希望在最后一次使用对象之后所执行的任何操作”，但在一般情况下，此函数被用来完成“清理工作”。如果用户没有定义析构函数，c++编译系统会自动生成一个析构函数，只是自动生成的析构函数只是徒有析构函数的名称和形式，实际上什么操作都不进行。

下面举个例子来说明：

#include<iostream>
using namespace std;

class String 
{
public:
	//有参构造函数
	String(char* s )
	{
		int length = strlen(s);
		this->ps = new char[length + 1];
		strcpy(this->ps, s);
		cout << "调用有参构造函数!" << endl;
	}

	//无参构造函数
	String()
	{
		this->ps = NULL;
		cout << "调用无参构造函数!" << endl;
	}

	//拷贝构造函数
	String(const String& s)
	{
		int length = strlen(s.ps);
		this->ps = new char[length + 1];
		strcpy(this->ps, s.ps);
		cout << "调用拷贝构造函数!" << endl;
	}

	//赋值函数
	String& operator=(const String& s)
	{
		if(this == &s) //第一步，判断是不是自我赋值
		{
			cout << "这是赋值函数!" << endl;
			return *this;
		}

		delete[] this->ps; //第二步，释放内存，如果在这里不释放内存，就没有机会释放内存了

		int length = strlen(s.ps);  //第三步，赋值
		this->ps = new char[length + 1];
		strcpy(this->ps, s.ps);
		cout << "调用赋值函数!" << endl;
		return *this;

	}

	//析构函数
	~String()
	{
		if( this->ps != NULL)
		{
			delete[] this->ps;
		}
		cout << "调用析构函数!" << endl;
	}
	void show()
	{
		cout << this->ps << endl;
	}
private:
	char *ps;
};
int main()
{
	char *name = "zou";

	String s(name); //调用有参构造函数
	s.show();

	String s1 = s; //这里调用的是拷贝构造函数，因为在这里s1没有实例化
	s1.show();

	String s2;
	s2 = s; //这里调用的是赋值构造函数
	s2.show();
	return 0;
}