c++类和对象新手保姆级上手教学（中）

前言：

类和对象中篇，这里讲到的前4个默认成员函数，是类和对象中的重难点，许多资料上的讲法都非常抽象，难以理解，所以我作出这篇总结，分享学习经验，以便日后复习。

6个默认成员函数：

构造函数：

1.概念：

2.用法：

3.特性：

析构函数：

1.概念：

2.用法：

3.特性：

4.析构调用顺序练习：

拷贝构造函数：

1.概念：

2.用法：

3.特性：

运算符重载：

用法：

赋值重载：

前置++和后置++重载：

取地址重载(不重要):

const成员函数：

6个默认成员函数：

什么是默认成员函数？

默认成员函数就是你不写编译器自己会自动生成的成员函数

前四个默认成员函数较为重要，后两个很少会自己实现，除非常特殊的情况下，基本上不会自己实现。

构造函数：

1.概念：

想必大家再用c语言实现栈，链表等数据结构的时候，都会先写一个初始化函数，来初始化我们的数据，但在使用中有时往往会忘记初始化，所以C++就产生了构造函数。

构造函数的作用就是进行初始化

2.用法：

那构造函数具体是怎样来使用的呢？举一个简单的案例，一个日期类的构造函数如下:

3.特性：

构造函数的函数名和类名相同。

无返回值。

对象实例化时编译器自动调用对应的构造函数。

构造函数支持重载。

建议写成全缺省。

一个类必须要有默认构造函数，如果你没有写，编译器会自己生成默认构造函数，但编译器默认生成的构造函数对内置类型不作处理，自定义类型去调用它的默认构造函数。但在C++11中委员会可能认为对内置类型不作处理显得很呆，所以对这个语法打补丁，支持在声明处给缺省值：

这样编译器默认生成的构造函数就会对内置类型进行处理。

但大多数情况下，构造函数都是需要我们自己去实现的。

无参构造函数，全缺省构造函数，编译器默认生成的构造函数，都可以称为默认构造函数，但一个类默认构造函数只能有一个，建议写成全缺省，避免歧义。

析构函数：

1.概念：

如果说构造函数的功能时初始化，那么析构函数就像它的死对头：

析构函数负责清理资源的工作，防止内存泄漏。

还是一样，我们在使用栈，链表等数据结构时最容易忘的就是用完后忘记清理空间，这将导致严重的后果，也就是内存泄漏，而C++中的析构函数可以有效解决这个问题。

2.用法：

由于我这个日期类不涉及动态资源，所以析构函数不必自己实现，但仍会调用：

3.特性：

函数名 = ~类名

无返回值

一个类只能有一个析构函数，如果不写编译器自己生成

析构函数不能重载

对象生命周期结束时，编译器自动调用析构函数

对于编译器自己生成的析构函数，同样是内置类型不作处理，自定义类型调用它自己的析构函数。

4.析构调用顺序练习：

对于析构函数，其实头疼的是它的多个函数析构时的调用顺序，这里给大家一个公式，大家以后套公式即可：

局部对象（后定义先析构）->局部静态（后定义先析构）->全局对象（后定义先析构）

下面由浅入深来练习一下：

练习1：

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year=1,int month=1,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
	~Date()
	{
		cout << "调用析构" << _year << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(1);
	Date d2(2);
	Date d3(3);
	return 0;
}

因为他们都是局部变量，遵循后定义先析构，所以：

练习2：

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year=1,int month=1,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
	~Date()
	{
		cout << "调用析构" << _year << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
Date d1(1);
Date d2(2);
Date d3(3);
int main()
{
	//Date d1(1);
	//Date d2(2);
	//Date d3(3);
	return 0;
}

现在他们都变为全局变量，仍遵循后定义先析构：

练习3：

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year=1,int month=1,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
	~Date()
	{
		cout << "调用析构" << _year << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(1);
	static Date d2(2);
	static Date d3(3);
	Date d4(4);
	return 0;
}

现在，d2变成局部静态，根据公式，先局部对象再局部静态，内部仍然按照后定义先析构：

练习4：

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year=1,int month=1,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
	~Date()
	{
		cout << "调用析构" << _year << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
Date d5(5);
static Date d6(6);
Date d7(7);
static Date d8(8);
int main()
{
	Date d1(1);
	static Date d2(2);
	static Date d3(3);
	Date d4(4);
	return 0;
}

先局部对象，再局部静态，最后全局，不管全局对象是否为静态，都遵循后定义先析构：