C++中的类与对象2——构造函数、析构函数、拷贝构造函数、赋值运算符重载函数

1 类的构造函数

1.1 构造函数的概念

对于以下的日期类

class Date{ 
public:
 void SetDate(int year, int month, int day)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 
 void Display()
 {
 cout <<_year<< "-" <<_month << "-"<< _day <<endl;
 }
private:
 int _year;
 int _month;
 int _day;
 }
 int main()
{
 Date d1,d2;
 d1.SetDate(2018,5,1);
 d1.Display();
 
 Date d2;
 d2.SetDate(2018,7,1);
 d2.Display();
 return 0;
 }
 

1 对于上面的Date类，可以通过SetDate公有的方法给对象设置内容，但是如果每次创建对象都调用该方法设置信息，未免有点麻烦，那么能否在对象创建的时候，就将对象信息自动设置了呢?
2 构造函数就是解决这个问题的，构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，保证了每个私有数据成员都有一个合适的初始值，并在对象的生命周期内只调用一次。

1.2 构造函数的特性

构造函数是特殊的成员函数，值得注意的是构造函数虽然名字叫构造，但是需要注意的构造函数的主要任务并
不是开空间创建对象，而是初始化对象。
其特征如下：
1. 函数名与类名相同
2. 无返回值
3. 对象实例化时编辑器自动调用对应的构造函数。
4. 构造函数可以重载

#include 
#include 
using namespace std;

class Date{
public:
	//1.无参构造函数
	Date(){

	}
	// 2.带参构造函数
	Date(int year, int month, int day){
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{

	Date d1; //调用无参构造函数   注意不要带括号：Date d1();否则就成了函数声明
	Date d2(2021, 8, 11);//调用带参构造函数

	system("pause");
	return 0;
}

5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
6. 无参的构造函数和全缺省的构造函数都是默认的构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数都可以认为是默认的构造函数。
如下面的代码会编译出错

#include 
#include 
using namespace std;

class Date{
public:
	//1.无参构造函数
	Date(){

	}
	// 2.带参构造函数
	Date(int year = 1000, int month = 23, int day = 12){
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{

	Date d1; //调用无参构造函数   注意不要带括号：Date d1();否则就成了函数声明
	//Date d2(2021, 8, 11);//调用带参构造函数

	system("pause");
	return 0;
}

7. 我们看下面的一个奇怪的现象

#include 
#include 
using namespace std;
class Date{
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1; //调用无参构造函数   注意不要带括号：Date d1();否则就成了函数声明
	system("pause");
	return 0;
}

上述代码调用了默认的无参构造函数，结果却是这样

关于编译器生成的默认成员函数，很有同学会有疑问：在我们不实现构造函数的情况下，编译器生成的默认成员函数没起到什么作用啊，数据还是随机值啊，编译器生成的默认成员函数并没有卵用？
其实是这样的：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好的类型：如
int/char…，自定义类型就是我们使用class/struct/union自己定义的类型，看看下面的程序，就会发现
编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数去初始化对象t(如果也是编译器自己默认那个也是啥都不干的哦)

#include 
#include 
using namespace std;
class Time{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 12;
		_minute = 12;
		_second = 12;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date{
private:
	int _year;
	int _month;
	int _day;
	Time t;
};
int main()
{
	Date d1; //调用无参构造函数   注意不要带括号：Date d1();否则就成了函数声明
	system("pause");
	return 0;
}

搜嘎了吧！

2 类的析构函数

2.1 析构函数概念

前面通过构造函数的学习，我们知道一个对象时怎么来的，那一个对象又是怎么没呢的？
析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源的清理工作。

2.2 析构函数的特性

析构函数是特殊的成员函数，其特性如下：

1. 析构函数名是在类名前加上字符~。
2. 无参数无返回值
3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
4. 对象生命周期结束时，C++编译系统自动调用析构函数。举个例子如下面的顺序表类

#include 
#include 
#include 
#pragma warning(disable:4996)
using namespace std;
class SeqList{
public:
	SeqList(int capacity){
		_arr = (int*)(malloc(sizeof(int)*capacity));
		assert(_arr);
		_capacity = capacity;
		_size = 0;
	}
	~SeqList(){
		if (_arr){
			cout << "~SeqList()" << endl;
			free(_arr);
			_arr = nullptr;
			_size = _capacity = 0;
		}
		
	}
private:
	int* _arr;
	int _size;
	int _capacity;
};
class MyString{
public:
	MyString(const char* str = "chenzhihao"){
		_str = (char*)malloc(strlen(str) + 1);
		strcpy(_str, str);
	}
	~MyString(){
		cout << "~MyString()" << endl;
		free(_str);
		_str = nullptr;
	}
private:
	char* _str;
};
class Person{
private:
	MyString _name;
	int _age;
};
int main()
{
	SeqList sl(12);
	Person p;
	return 0;
}

5. 关于编译器自动生成的析构函数，是否会完成一些事情呢：从上面的程序源代码可以看出来编译器生成的默认的析构函数，会对自定义类型的成员调用它的析构函数。

3 类的拷贝/复制构造函数

3.1 拷贝/复制构造函数的概念

在创建对象时候，可否创建一个与一个对象一模一样的新对象呢？
复制构造函数：只有一个形参，该形参是对本类类型对象的引用(一般是常引用)，在用已经存在的类类型对象创建新对象时候由编译器自动调用。

3.2 拷贝/复制构造函数的特征

拷贝构造函数也是特殊的成员函数，其特征如下：
1. 拷贝构造函数是构造函数的一个重载形式
2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无尽的递归调用。

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 Date(const 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);
 return 0; 
 }

3. 若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝或值拷贝。
4. 那么编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像日期类这样的类是没必要的，如果是下面这样的类呢？编译代码会过吗？运行会出错吗？

#include 
#include 
#include 
#pragma warning(disable:4996)
using namespace std;
class MyString{
public:
	MyString(const char* str = "Tom"){
		_str = (char*)malloc(strlen(str) + 1);
		strcpy(_str, str);
	}
	~MyString(){
		cout << "~MyString()" << endl;
		free(_str);
		_str = nullptr;
	}
private:
	char* _str;
};
int main()
{
	MyString s1("czh");
	MyString s2(s1);
	return 0;
}

答案是：编译是可以过的，但是运行程序是会崩溃的，因为默认的拷贝构造函数只是值(浅)拷贝，_str是一样的，也就是指向了一块内存空间，在s2调用析构函数的时候会把_str指向的空间释放掉，再s1调用析构函数释放的还是这个空间，此时这个空间已经被操作系统回收，这块空间已经不属于s1，也即是释放了不属于自己的空间，导致了程序崩溃。

4 类的赋值运算符重载函数

4.1 运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表和普通函数类似。
函数的名字为：关键字operator + 需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)
注意：
不能通过连接其他操作符来创建新的操作符:比如operator@
重载操作符必须有一个类类型或者枚举类型的操作数。
用于内置类型的操作符其含义不能改变，例如：内置的整型+，不能改变其含义
作为类成员的重载函数时，形参列表的第一个参数是：类型 this指针。*
. :: szieof ?: . 这5个运算符不能重载*。

class Date
{ 
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 
 // bool operator==(Date* this, const Date& d2)
 // 这里需要注意的是，左操作数是this指向的调用函数的对象
 bool operator==(const Date& d2)
 {
 return _year == d2._year;
 && _month == d2._month
 && _day == d2._day;
 }
 private:
 int _year;
 int _month;
 int _day;
}
void Test ()
{
 Date d1(2018, 9, 26);
 Date d2(2018, 9, 27);
 cout<<(d1 == d2)<<endl; 
 } 

4.2 赋值运算符重载

赋值运算符主要有以下几点需要注意：

1. 参数类型
2. 返回值
3. 检测是否自己给自己赋值
4. 返回*this
5. 一个类如果没有显式定义赋值运算重载，编译器也会生成一个，完成对象按字节序的值（浅）拷贝。

那么编译器生成的默认赋值重载函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像
日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
class String
{
public:
 String(const char* str = "")
 {
 _str = (char*)malloc(strlen(str) + 1);
 strcpy(_str, str);
 }
 ~String()
 {
 cout << "~String()" << endl;
 free(_str);
 }
 private:
 char* _str;
};
int main()
{
 String s1("hello");
 String s2("world");
 
 s1 = s2; 
 }

这里就会发生和上面的拷贝构造函数同样的情况，程序会崩溃，原因也是重复析构导致的问题，需要深拷贝来解决，后面我会写到的。