构造函数、析构函数、拷贝构造函数（浅拷贝和深拷贝）、移动构造函数、赋值函数的区别

基础知识：

      突然发现看了这么久的C++知识点，突然一写发现连拷贝构造函数和赋值函数都写不来了。重新看了书，梳理了语法规范和注意事项，现在整理一下。

构造函数：

       构造函数主要是进行成员变量的初始化，有成员列表初始化和构造函数体内的赋值初始化。写法如下：

//构造函数名和类名相同，可以有多个
class example{
public:
    example(int x, int* y):a(x),b(y){}//成员列表初始化
    //example(int x, int* y)//构造函数，函数体内初始化变量。
    //{
    //    a = x;
    //    b = y;
    //}

private:
    int a;
    int* b;
}

//使用
int p = 1;
int* q = 5;
class example a(p,q);

拷贝构造函数:

       拷贝构造函数的主要作用是利用一个已有的对象对新建对象进行初始化，拷贝构造函数主要分为深拷贝和浅拷贝。

       浅拷贝：有指针变量的情况下，将当前成员指针类型变量指向传入的对象的相同指针变量(两个指针指向的是同一块内存)

       深拷贝：有指针变量的情况下，将当前成员指针类型变量申请一块新内存，存放传入对象相同指针变量的内容

//构造函数名和类名相同，可以有多个
class example{
public:
    example(int x, int* y):a(x),b(y){}//成员列表初始化
    example(const example& t)//浅拷贝构造函数
    {
        a = t.a;
        b = t.b;
    }
    example(const example& t)//深拷贝构造函数
    {
        a = t.a;
        b = new int(*t.b);//注意要传值
    }


private:
    int a;
    int* b;
}

//使用
int p = 1;
int* q = 5;
class example a(p,q);

       拷贝构造函数主要用于以下三种情况：

       1.成员变量初始化：

class example a; 
class example b(a);
//或者class example a = b;(特别注意，这里调用了拷贝构造函数，而不是赋值函数)

      2.动态创建对象

class example a;
class example b = new example(a);

     3.函数的传值调用

void test(examle obj);

析构函数：

       析构函数主要是释放内存。写法如下：

//构造函数名和类名相同，可以有多个
class example{
public:
    example(int x, int* y):a(x),b(y){}//成员列表初始化
    example(const example& t)//深拷贝构造函数
    {
        a = t.a;
        b = new int(*t.b);//注意要传值
    }
    ~example()//析构函数
    {
        delete b;//如果有自己动态申请的内存时，最好delete释放内存
    }

private:
    int a;
    int* b;
}

//使用
int p = 1;
int* q = 5;
class example a(p,q);

移动构造函数：

       可能一开始接触到这个玩意儿，不知道是个啥。它也是构造函数的一种，主要的作用当然也是初始化变量。我们知道拷贝构造函数它有深拷贝和浅拷贝。当我们用完一个对象，不需要再用这个对象时，并且不想再重新申请内存，那么我们考虑使用移动拷贝构造函数。写法如下：

class object{
public:
	object(int x, int* y) :a(x), b(y){}//构造函数

	object(const object& t)//拷贝构造函数（深拷贝）
	{
		a = t.a;
		b = new int(*t.b);
		cout << "深拷贝构造函数" << endl;
	}

	object(object&& t)//移动构造函数（注意里边不能加const）
	{
		a = t.a;
		b = t.b;
		t.b = nullptr;//我们使用浅拷贝，指向该对象变量指向的内存块，然后将原对象的指针置NULL，这样就只有当前对象的指针指向了那块内存
		cout << "移动构造函数" << endl;
	}

	~object()
	{
		delete b;
	}

private:
	int a;
	int* b;
};

赋值函数：

       该函数是在非申明阶段，相同类对象之间赋值调用的函数。写法如下：

class object{
public:
	object(int x, int* y) :a(x), b(y){}//构造函数
	object(const object& t)//拷贝构造函数（深拷贝）
	{
		a = t.a;
		b = new int(*t.b);
		cout << "深拷贝构造函数" << endl;
	}

	object& operator = (const object& t)//实际上就是重载了‘=’运算符
	{
		a = t.a;
		b = t.b;
		cout << "赋值函数" << endl;
		return *this;//记得返回值
	}

private:
	int a;
	int* b;
};

 

所有函数调用：

#include <iostream>

using namespace std;

class object{
public:
	object(int x, int* y) :a(x), b(y){}//构造函数
	//object(const object& t)//拷贝构造函数（浅拷贝）
	//{
	//	a = t.a;
	//	b = t.b;
	//	cout << "浅拷贝构造函数" << endl;
	//}

	object(const object& t)//拷贝构造函数（深拷贝）
	{
		a = t.a;
		b = new int(*t.b);
		cout << "深拷贝构造函数" << endl;
	}

	object& operator = (const object& t)
	{
		a = t.a;
		b = t.b;
		cout << "赋值函数" << endl;
		return *this;
	}

	object(object&& t):b(t.b)//移动构造函数
	{
		a = t.a;
		b = t.b;
		t.b = nullptr;
		cout << "移动构造函数" << endl;
	}

	~object()
	{
		delete b;
	}

private:
	int a;
	int* b;
};

int main()
{
	int x = 1;
	int* y = new int(9);
	
	int p = 6;
	int* q = new int(6);

	object a(x,y);//调用构造函数
	object b(p,q);
    object c(a);//调用拷贝构造函数
    object d = b;//调用拷贝构造函数（和下面赋值函数注意区分）

	a = b;//调用赋值函数

	system("pause");
	return 0;
}