前言：

hello，大家好，今天我们来继续更新C++有关类和对象的知识，熬过了上一篇文章，我们已经来到了第二重境界——衣带渐宽终不悔，为伊消得人憔悴。闲言少叙，让我们来开始吧。

1.类的六个默认成员函数

我们先来看一个简单的类:

#include<iostream>
using namespace std;
class Date
{
   
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
   

}

在这个类里面，我们没有声明定义成员函数，那么真的就没有成员函数吗？
其实啊，就算我们什么都不写，编译器也会自动为我们生成6个成员函数，成为默认成员函数。这有点类似于我们之前讲过的缺省（忘了缺省的小伙伴可以点击链接回顾哦---->C++之缺省参数：其实我是备胎）。
那么这6个默认成员函数都是什么呢？请看下图

下面，我们将依次介绍这几个函数。

2.构造函数

2.1概念

好的，我们先来看一个日期类

#include<iostream>
using namespace std;
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;
}

我们观察这个类发现，我们通过setDate函数赋予对象内容，来完成初始化，这样是可以的，但有些时候也许会有一些麻烦，比如像下面这样

在这个程序中，我们创建了一个d1，但是我们忘记了还没有对它进行初始化，就调用了Display函数，这显然是错误的。所以，我们迫切地需要找到一种好的方法来解决这种可能会发生的疏忽，于是构造函数横空出世。

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有一个合适的初始值，并且在对象的生命周期内只调用一次。

为什么说构造函数可以解决这个问题呢？让我们来继续了解它吧。

2.2特性

构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
构造函数具有如下特点：

函数名与类名相同。
无返回值。
注意：有void不叫无返回值，void表示返回值为空。
对象实例化时编译器自动调用对应的构造函数。（保证对象一定初始化）
构造函数可以重载。
这样可以保障多种初始化方式：

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;
};
void TestDate()
{
   
	Date d1; // 调用无参构造函数
	Date d2(2015, 1, 1); // 调用带参的构造函数
	// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
	// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
	Date d3();

如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

class Date
{
   
public:
/* // 如果用户显式定义了构造函数，编译器将不再生成 Date (int year, int month, int day) { _year = year; _month = month; _day = day; } */
private:
int _year;
int _month;
int _day;
};
void Test()
{
   
// 没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器生成的默认构造函数
    Date d；
}

无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。

/ 默认构造函数
class Date
{
   
public:
Date()
{
   
_year = 1900 ;
_month = 1 ;
_day = 1;
}
Date (int year = 1900, int month = 1, int day = 1)
{
   
_year = year;
_month = month;
_day = day;
}
private :
int _year ;
int _month ;
int _day ;
};
// 以下测试函数能通过编译吗？
void Test()
{
   
Date d1;
}

这段代码能编过吗？我们来看一下运行结果：

很遗憾并没有编过，所以这要引起我们的反思：注意，无参的构造函数和全缺省的构造函数还有编译器默认生成的构造函数都称为默认构造函数，但默认构造函数只能有一个。在上面的代码中，我们既有无参的构造函数又有全缺省的构造函数，所以我们是无法编译通过的。

当我们去掉一个

我们发现程序就可以编译通过啦。
8. 关于编译器生成的默认成员函数，也许我们会有这样的疑惑：在我们不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但d对象year/month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？这又是为什么呢？

存在即合理，编译器自动生成的构造函数并非是什么都不做的哦。
其实啊，C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好的类型：如int/char…，自定义类型就是我们class/struct/union自己定义的类型，编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数
让我们来理解一下：
先看一下这段代码

#include<iostream>
using namespace std;
class A
{
   
	int _a;
public:
	A(int a=0)
	{
   
		cout << "A(int a=0)构造函数" << endl;
		_a = a;
	}
	void Print()
	{
   
		cout << _a << endl;
	}
};
class Date
{
   
	int _year;
	int _month;
	int _day;
	A _aa;
public:
	void print()
	{
   
		cout << _year << "-" << _month << "-" << _day << endl;
		_aa.Print();
	}
};
int main()
{
   
	Date d;
	d.print();
	return 0;
}

9. 成员变量的命名风格
一般建议在数据成员名称前加_或m_。以便于区分哦。

3. 析构函数

3.1概念

通过之前的介绍，我们知道，构造函数是用来初始化对象的，那么对象又是怎么被清理的呢？于是，我们的析构函数出场啦。

与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

2.2特性

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

#include<iostream>
using namespace std;
class Date
{
   
private:
	int _year;
	int _month;
	int _day;
public:
	Date(int year,int month,int day)
	{
   
		_year = year;
		_month = month;
		_day = day;
	}
	~Date()
	{
   
		cout << "析构函数" << endl;
	}
};
int main()
{
   
	Date d(2021,7,21);
	return 0;
}

6.先构造的后析构，后构造的先析构

#include<iostream>
using namespace std;
class Date
{
   
private:
	int _year;
	int _month;
	int _day;
public:
	Date(int year,int month,int day)
	{
   
		cout << "构造";
		_year = year;
		_month = month;
		_day = day;
		cout << _year << "-" << _month << "-" << _day<<endl;
	}
	~Date()
	{
   
		cout << "析构" << _year << "-" << _month << "-" << _day << endl;
	}
};
int main()
{
   
	Date d1(2021,7,21);
	Date d2(2022, 7, 21);
	return 0;
}

4.拷贝构造函数

4.1概念

还记得真假美猴王吗？两个猴子一模一样，搞得唐僧傻傻分不清，那么在C++中，我们又该如何上演一出真假美猴王的大戏呢？于是，我们来到了这一部分，拷贝构造函数。

首先，什么是拷贝构造函数呢？

只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用

4.2特性

拷贝构造函数是构造函数的一个重载形式。
拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用

为什么会这样呢？我们看，第一个是传值，第二个是传引用。我们知道，传值是一种拷贝，所以，如果采用第一种方式，我们需要不断传参，不断调用拷贝构造，这是一个死结，所以会报错。

当我们传引用的时候，只是一个别名，不需要拷贝，也就不涉及上面的问题，所以切记，要用引用传参&。这也给了我们一个思考：
若未显示定义，系统生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。

#include<iostream>
using namespace std;
class Date
{
   
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
   
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
   
	Date d1;

	// 这里d2调用的默认拷贝构造完成拷贝，d2和d1的值也是一样的。
	Date d2(d1);
	return 0;
}

4.那么编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？
我们来看一下：

#include<iostream>
using namespace std;
class String
{
   
public:
	String(const char* str = "jack")
	{
   
		_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(s1);
}

猜一猜这个程序可以通过吗？我们来看一下：

我们发现它在运行的时候会崩溃，这就要引发我们的思考，为什么会崩溃呢？我们来分析一下：
在这个程序中，在拷贝构造的时候，拷贝前后指向的是同一块空间。

所以，这个时候我们需要深拷贝。限于篇幅，我们先不在这里详细介绍深拷贝，之后博主会继续写文章来介绍深拷贝。

总结

好的，我们今天的分享就先到这里啦。感谢大家支持，也欢迎大家批评指正。今天我们分享了类和对象的第二篇文章，到了“衣带渐宽终不悔，为伊消得人憔悴”的境界，下一次我们将分享关于类和对象的第三篇文章，欢迎大家继续支持哦。最后让我们分享一下柳永的《蝶恋花·伫倚危楼风细细》：

伫倚危楼风细细。望极春愁，黯黯生天际。
草色烟光残照里。无言谁会凭阑意。
拟把疏狂图一醉。对酒当歌，强乐还无味。
衣带渐宽终不悔。为伊消得人憔悴。

C++之类和对象2：消得人憔悴

目录

前言：

1.类的六个默认成员函数

2.构造函数

2.1概念

2.2特性

3. 析构函数

3.1概念

2.2特性

4.拷贝构造函数

4.1概念

4.2特性

总结