C++ 类与对象（中） 默认成员函数

       我们知道在类中，有成员变量和成员函数，我们可以通过创造不同的成员函数来实现这个类不同的功能，如果我们创造一个类，却不实现它的成员函数会如何呢？这个就涉及到类中的默认成员函数的概念了。但在本文我们主要介绍以下几个默认成员函数：构造函数，析构函数，拷贝构造函数，赋值运算符重载。

一  构造函数

       构造函数虽然称为“构造”，但构造函数的作用并不是开辟空间创造对象，而是对象实例化时初始化对象，类似于初始化的作用。

        在C语言学习结构体中，我们实现过链表，栈，队列二叉树等，以栈为例，在定义一个栈后，我们还需要对栈这个结构实现两个必不可少的功能函数：初始化和销毁。

typedef struct Stack{
    int*arr;
    int top;
    int capacity;
}ST;

void StackInit(ST*st){
     ........

}

void StackDestory(ST*st){
     ........
}

       在C语言中当我们声明一个栈类时，如果忘记将这个栈初始化，编译器就会报错，如果在栈使用完后忘记销毁，有可能造成内存泄露，这两个问题都是我们不想碰见的，但在C++中构造函数和析构函数可以完美解决这两个问题，讲到这里，前菜结束，主菜上场！

       在C++中，构造函数是自动调用的，完美的替代了Init函数，也不怕我们在程序中忘记对对象进行初始化，对程序员非常的友好。

对于构造函数的特点，也是非常的多：

1.构造函数的函数名与类名相同

2.无返回值

3.对象实例化时系统会自动调用对应的构造函数

4.构造函数可以重载

5.如果我们在类中没有写（显式）定义构造函数，那么编译器会自当生成一个无参的默认构造函数

class Date {
	//系统默认生成的构造函数（如果我们没有显式定义构造函数）
	 
	//全缺省构造函数
	Date(int year = 1,int month=1,int day=1) {
		_year = year;
		_month = month;
		_day = day;
	}

	//无参构造函数
	Date() {
		_year = 1;
		_month = 1;
		_day = 1;
	}
private:
	int _year;
	int _month;
	int _day;
};

6.C++中有三个默认构造函数：无参构造函数，全缺省构造函数，以及编译器默认生成的构造函数，但是这三个函数有且仅只有一个存在，不能同时存在，不然调用的时候就会有歧义（和缺省函数时一样）

7.对于编译器生成的默认构造函数，对内置类型成员的初始化没有要求，是否初始化是不确定的，如果一个类中有自定义类型，那么自定义类型会调用它的默认构造函数，如果没有的话编译器就会报错

注意：带参构造函数并不是默认成员函数

class Date {
public:
	//带参构造函数并不是默认成员函数
	Date(int year, int month, int day) {
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

最后在这里总结一下构造函数：

       构造函数名与类名一致，如果不显式实现则系统会自动生成一个构造函数，但该函数对内置类成员的初始化是不确定的，对自定义类类型成员会调用它自己的默认构造函数，带参构造函数不是默认成员函数，对象实例化时系统会默认调用构造函数对其初始化。

二  析构函数

如果将构造函数有初始化的作用，那么析构函数就有清理作用（但不是销毁，只是类比destory）

       C++规定在对象销毁时会自动调用析构函数，对对象中的资源进行清理释放，我们不需要主动去调用该函数，系统会自动帮我们调用。

       那么析构函数有声明特点呢，它是怎么写的呢？

1.析构函数的函数名，就是类名前多加一个~

2.无参无返回值，如果我们不自己主动实现，那么系统会自动生成一个析构函数

3.一个类只能有一个析构函数

class Date {
public:
    //显式析构函数
	~Date() {
		......
	}
private:
	int _year;
	int _month;
	int _day;
};

4.生命周期结束时，系统会自动调用析构函数

5.对于自定义类型无论我们是否在类中实现其析构，自定义类型都会自动调用它的析构函数

6.如果类中没有申请资源，析构函数可以不写，但有资源申请时一定要写，不然可能会造成内存的泄露

7.对于一个类中多个对象，后定义的对象先析构

class Date {
public:
	~Date() {
		cout << "~Date()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main() {
    //后定义的先析构
	Date d1;
	Date d2;
	Date d3;
    //对象析构顺序：d3 -> d2 -> d1
}

最后对于析构函数的总结，这里用一张有趣的图进行概括：

三  拷贝构造函数

       如果一个构造函数的第一个参数是自身类型的引用，那么这个函数就是拷贝构造函数，拷贝构造函数是构造函数的一个重载函数。

当我们想用一个类类型对象复制给另一个类类型对象，我们就需要用到拷贝构造函数。

注意：是一个已经实例化的对象给还未实例化的对象初始化

以日期类为例：

class Date {
public:
	//构造函数
	Date() {
		_year = 100;
		_day = 100;
		_month = 100;
	}
	//Date类不需要析构函数，但这里为了直观感受还是写一个
	~Date() {
		cout << "~Date()" << endl;
	}

	//拷贝构造函数,第一个形参为什么加const，下面再细讲
	Date(const Date& d) {
		//函数在这里其实也是通过this指针找到相应的对象的
		//this->_year = d._year;
		_year = d._year;
		_month = d._month;
		_day = d._day;

	}

	void print() {
		cout << _year << " " << _month << " " << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main(){
    Date d1;
    //这样写也可以
    //Date d2=d1;
	Date d2(d1);
	d1.print();
	d2.print();
}
//打印结果
100 100 100
100 100 100
~Date()
~Date()

对于拷贝构造函数的特点：

1.拷贝构造函数是构造函数的一个重载函数，第一个参数必须是类类型成员的引用，后面其他的参数必须要有缺省值

2.C++规定对自定义类型对象进行拷贝行为必须调用拷贝构造，所以自定义类型传值传参返回都会调用拷贝构造完成

在这里我们就可以解释：为什么拷贝构造函数的第一个函数是引用自定义类型

如果我们不加引用，每次调用拷贝构造函数时之前要传参传值，传值传参是一种拷贝，又形成了一种新的拷贝构造，就形成了无穷递归：

class Date {
public:
	//构造函数
	Date() {
		_year = 100;
		_day = 100;
		_month = 100;
	}
	//Date类不需要析构函数，但这里为了直观感受还是写一个
	~Date() {
		cout << "~Date()" << endl;
	}
    //不写引用，会引发无限调用
	Date(Date d) {
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main() {
	Date d1;
	Date d2(d1);
}

3.若未显式定义拷贝构造，编译器会自动生成拷贝构造函数。自动生成的拷贝构造函数对内置类成员变量会完成值拷贝/浅拷贝，对自定义类型成员会调用他的拷贝构造

class Stack {
public:
	Stack(int n=4) {
		_arr = (int*)malloc(sizeof(int) * n);
		if (_arr == nullptr) {
			perror("malloc");
		}
		_capacity = n;
		_top = 0;
	}
	~Stack() {
		free(_arr);
		_arr = nullptr;
		_capacity = _top = 0;
		cout << "~Stack()" << endl;
	}
	//对于栈类来说，析构函数有资源的释放，所以我们需要自己实现拷贝构造函数
	Stack(const Stack& st) {
		//需要对_arr指向资源创建同样大的资源再拷贝值，也就是深拷贝
		_arr = (int*)malloc(sizeof(int) * st._capacity);
		//空间创建了，再将值拷贝过去
		memcpy(_arr, st._arr, sizeof(int) * st._top);
		_capacity = st._capacity;
		_top = st._top;
	}
private:
	int* _arr;
	int _top;
	int _capacity;
};
class Myqueue {
public:

private:
	Stack stPush;
	Stack stPop;
};
int main(){
    Stack st1;
    //调用的不是Myqueue类中的拷贝构造函数，而是Stack类中的拷贝构造
    Stack st2(st1);
}

4.像Date类这种没有资源指向的类，编译器自动生成的构造函数已经足够我们使用，但是对于一些又资源指向的类，我们就需要深拷贝了，换句话说：我们需要自己实现拷贝构造函数

以栈类为例，栈类有资源的申请和清理

如果使用系统默认生成的浅拷贝，那么调用拷贝构造后两个栈都会指向同一块空间，这并不能达到我们想要的效果，因此我们需要自己实现拷贝构造函数，通过深拷贝实现

class Stack {
public:
	Stack(int n=4) {
		_arr = (int*)malloc(sizeof(int) * n);
		if (_arr == nullptr) {
			perror("malloc");
		}
		_capacity = n;
		_top = 0;
	}
	~Stack() {
		free(_arr);
		_arr = nullptr;
		_capacity = _top = 0;
		cout << "~Stack()" << endl;
	}
	//对于栈类来说，析构函数有资源的释放，所以我们需要自己实现拷贝构造函数
	Stack(const Stack& st) {
		//需要对_arr指向资源创建同样大的资源再拷贝值，也就是深拷贝
		_arr = (int*)malloc(sizeof(int) * st._capacity);
		//空间创建了，再将值拷贝过去
		memcpy(_arr, st._arr, sizeof(int) * st._top);
		_capacity = st._capacity;
		_top = st._top;
	}
	void Push(int x) {
		if (_top == _capacity) {
			int _newcpacity = 2 * _capacity;
			int* tmp = (int*)malloc(sizeof(int) * _newcpacity);
			_arr = tmp;
			_capacity = _newcpacity;
		}
		_arr[_top++] = x;
	}
private:
	int* _arr;
	int _top;
	int _capacity;
};

在最后，讲解一下为什么在拷贝构造函数中的第一个参数要加const

在下面的代码中，有两个返回值是Date类的函数 f 和 fun 

当我们以 f() 的返回值作为 fun() 的形参时，这其实是不对的，因为在f()函数中，返回的Date类是一个临时对象，而临时对象具有常性，一个常性变量传递给引用类型，这其实是权限的放大，所以我们在设置拷贝构造函数时，形参最好加上const以免遇到这种情况

class Date {
private:
	int _year;
	int _month;
	int _day;
};
Date f() {
	return ret;
}
Date fun(Date& d) {
	cout << "fun()" << endl;
}
int main() {
	Date d1(f());
}

四  运算符重载 

运算符重载其实是均有特殊名字的函数，它的名字由operator和后面要定义的运算符共同构成，有对应的参数和返回类型

重载运算符函数的参数个数和该运算符的运算对象数量一样多：一元运算符有一个参数，二元运算符有两个参数.......

如果一个重载运算符函数是成员函数，则它的第一个运算对象默认传给隐式的this指针，因此当它是成员函数时，参数要少写一个

运算符重载后，其优先级和结合性不变

以运算符‘< ’为例，我们可以对<进行重载，

class Date {
private:
	int _year;
	int _month;
	int _day;
};

//类中的成员被private修饰，外部无法访问
bool operator<(Date& d1,Date& d2) {
	return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}

//解决方法：将运算符重载放到类中，那么就可以访问类中成员了
class Date {
public：
    return _year == d._year && _month == d._month && _day == d._day
private:
	int _year;
	int _month;
	int _day;
};

 当重载为全局时，会面临对象访问私有成员变量的问题，也有几种方法解决：

1.重载为成员函数

2.友元

3.将私有成员公有化（不推荐）

4.Date类提供接口让外部获取私有变量

五  赋值运算符重载

在运算符重载中，有个运算符非常的特殊：=，对于赋值运算符的重载有着一定的限制

赋值运算符重载时一个默认的成员函数，用于两个已经存在的对象直接的拷贝赋值

赋值运算符重载一定要重载为成员函数，参数建议写成const当前类类型引用，返回值也建议写成当前类类型引用，以提高效率，有返回值是为了支持连续赋值的场景

与构造函数和析构函数一样，如果没有显式实现，系统会默认生成。对于自定义类型会调用其赋值重载函数

如果类中指向了资源，那么我们就需要自己显式实现赋值运算符重载，像下面的日期类，其实我们是不用显式实现的，系统自动生成的赋值运算符重载就已经满足使用要求了，因为它没有资源的指向

class Date {
public:
		//d1 = d2，通过引用返回能减少拷贝
	Date& operator=(const Date& d) {
		//自己赋值给自己没必要
		if (this != &d) {
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		//d1 = d2,返回的应该是对象d1，也就是隐式this所指向的对象
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};

六  判断什么时候需要自己显式实现

       构造函数一般都要自己写，自己通过传参定义初始化，就算是内置类成员，系统自动生成的构造函数初始化是不确定的，不一定满足我们的要求

       析构函数是否显式要看构造时是否有资源的申请，如果有那么就要写，如果没有，自动生成的那个也足够使用

       对于拷贝构造和赋值重载，如果我们显式写了构造或者有内部资源管理的情况，那么我们就需要显式实现深拷贝