C++类的六大默认成员函数详解-优快云博客

本文链接：https://blog.youkuaiyun.com/Amour_Old_flame/article/details/83755711

类的6个默认成员函数：

如果我们定义了一个类，里面什么都没有，就是空类？

可是空类里面真的什么都没有吗？其实并不是这样的，任何一个类在我们不写的情况下他都会自动生成6个默认成员函数。

class Date{};

1.构造函数：

构造函数的名字与类的名字相同，用类创建对象时由编译器自动调用，可以用来初始化对象。

特性：

1.构造函数的名字和类的名字相同

2.构造函数没有返回值。

3.对象实例化时由编译器自动调用，不用我们调用。

4.构造函数也可以重载

5.无参的构造函数和全缺省的构造函数成为默认构造函数，默认构造函数只能有一个

下来我们用代码来解释一下构造函数。

#include <iostream>

using namespace std;

class Date
{
public:
	Date()//无参构造函数
	{
		cout << "I am Date" << endl;
	}

	Date(int year, int month, int day)//有参构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(2018, 11, 5);
	d1.print();
	d2.print();
	return 0;
}

、

通过程序的运行我们发现即使我们没有调用构造函数，但是编译器会主动帮我们自动调用。

而且我们也发现了构造函数可以重载。

当我们实例化d1这个对象的时候，就调用了无参的构造函数

而当我们实例化d2这个对象时，因为我们传入了参数，所有他调用了有参数的构造函数。进行了我们对象的初始化。

需要注意的是：当我们没有显示定义构造函数，编译器会帮我们自动生成一个无参的构造函数，一旦我们定义则不生成。

下面解释一下第五点：

5.无参的构造函数和全缺省的构造函数成为默认构造函数，默认构造函数只能有一个

全缺省的构造函数就是我们的参数都有默认值的情况就叫做全缺省

class Date
{
public:
	Date()//无参构造函数
	{
		cout << "I am Date" << endl;
	}

	Date(int year = 1900, int month = 2, int day = 1)//有参构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

我们发现出现了错误，这是为什么呢？

因为他们都是默认构造函数，在实例化对象的时候编译器不知道该调用哪一个？

当我们实例化对象时,调用无参的构造函数不用传入参数，可是调用全缺省的构造函数也可以不穿参数对吧，可以全部都是默认值，这就导致我们程序出现了错误，所以要注意这一点。

构造函数之初始化列表：

什么是初始化列表呢？

以一个冒号开始，接着是一个以逗号分隔的成员列表，每个成员变量后面跟一个放在括号里的初值或者表达式。

需要注意的是：每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次）。

可能不太容易理解，我们结合代码看一下。

#include <iostream>

using namespace std;

class Date
{
public:
	Date(int year, int month, int day) 
		:_year(year)
		, _month(month)
		, _day(day)
	{}
	
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d2(1900,1,1);
	d2.print();
	return 0;
}

也可以完成初始化，那我们构造函数里面可以进行初始化，为什么还要存在初始化列表呢？

这里我们需要理解构造函数的函数体内只能做赋值而不是初始化。

因为有些情况只能用我们的初始化列表进行初始化。

class Day
{
public:
	Day(int days)
	{
		_days = day;
	}
private:
	Day _aaa;//没有默认的构造函数
	int &ret;//引用
	const int _days;//const修饰的
};

当类中有一下三种成员只能用初始化列表初始化。

引用成员变量：只能初始化，不能赋值
const成员变量：const修饰后就是常量无法修改，所有只能用初始化列表。
类类型成员(该类没有默认构造函数)：因为该类没有默认构造函数，所以必须用初始化列表初始化。

2.析构函数：

在我们了解了构造函数之后，我们知道一个对象怎么来的，那么析构函数就可以让我们了解一个对象怎么没的。

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

特性：

1.函数名是类名前加 ~。

2.析构函数既没有返回值，也没有参数。（没有参数，从这一点我们就可以分析出构函数是无法重载的）。

3.一个类只有一个析构函数，如果我们没有显示的定于，编译器会默认生成一个。

4.一个对象生命周期结束的时候，系统会自动调用析构函数。

下面我们结合代码认识一下

class Array
{
public:
	Array()
	{
		_p = new int[10];
		cout << "I am Array,new finish" << endl;
	}
	~Array()
	{
		if (_p)
		{
			delete[] _p;
		}
		cout << "I am ~Array,clean finish" << endl;
	}
private:
	int* _p;
};

int main()
{
	Array a1;
	return 0;
}

果然编译器自动帮我们调用了析构函数，帮助我们完成了清理。而且我们也发现先调用的是我们的构造函数，后面才调用的析构函数。

这也正体现了：创建对象时调用构造函数，销毁对象前调用析构函数。

3.拷贝构造函数：

顾名思义，拷贝构造函数的作用就是进行拷贝。就像我们现实中的双胞胎一样。

是不是很像呢？哈哈

拷贝构造函数，从名字我们能不能读出点信息呢？他其实也可以算是构造函数重载的一种，只是参数比较特殊。

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

特性：

1.拷贝构造函数其实也是构造函数重载的一种形式。

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

3.如果我们没有显示定义，系统会默认生成一个，默认拷贝构造函数对象按内存存储按字节序完成拷贝。

下面用代码来认识一下

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;
		cout << "I am copy" << endl;
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(d1);
	d1.print();
	d2.print();
	return 0;
}

通过程序的运行我们发现实例化d2的时候调用了拷贝构造，所以d2和d1的值是一样的。这就是拷贝构造函数。

这里可以能有疑问？为什么要引用传参呢？值传参可不可以？这就是特性的第二点。

对于特性的第一点相信大家都没有什么疑问，接下来我来解释第二点

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

因为传值本身就是一种拷贝的过程，传引用我们知道是传别名，但其实还是自己。

但我们传值却是进行再一次的对象拷贝，然后就会形成无限的拷贝死循环。就像下面这样

无穷无尽就形成了死循环，而传引用却不会所以需要注意，不能传值。

4.赋值运算符重载：

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类
型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

通俗的讲就是我们内置类型比如int char long可以用我们的 + - == = += 这写运算符进行运算，但是对于我们的自定义类型却没有办法进行这类运算。

以下面的代码为例：

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;
	Date d2;
	d1 += d2;
	return 0;
}

我们发现并不能进行运算，这时候我们的运算符重载就可以派上用场，把我们的运算符进行重载之后就可以进行我们的自定义类型的运算。

函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表) 下面给我重载==的代码认识一下。

bool operator==(const Date& d1, const Date& d2)
{
 return d1._year == d2._year;
 && d1._month == d2._month
 && d1._day == d2._day;
}

如果要了解其他运算符重载请戳这里：https://github.com/Amour132/class-Date/tree/master/Date/Date

运算符重载有一下几点需要注意：

1.不能通过连接其他符号来创建新的操作符：比如operator@
2重载操作符必须有一个类类型或者枚举类型的操作数
3.用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义。（如果改变很容易会出错）
4.作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的
5.操作符有一个默认的形参this，限定为第一个形参
6..* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。

赋值运算符则需要注意：

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

在了解后面两个默认成员函数之前我们先在了解一个概念：

const成员函数：

const成员函数就是const修饰类的成员函数：const修饰类成员函数，实际上就是修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

可以表示成这样

这就是const成员函数。他们是完全相等的关系。

5.and 6 取地址及const取地址操作符重载

这两个默认成员一般不用我们自己重新定义，编译器会默认生成。这两个相对来说自己定义的很少。

我们结合代码看一下

class Date
{ 
public :
 Date* operator&()
 {
 return this ;
 }
 
 const Date* operator&()const
 {
 return this ;
 }
private :
 int _year ; // 年
 int _month ; // 月
 int _day ; // 日
};

需要注意的是：这两个运算符一般情况下不需要重载，使用编译器生成的默认取地址的重载就可以了，只有少数特殊形况需要重载，比如我们我们想让别人获取到指向的内容，这时候就需要重载，其他一般不会重载。

以上就是类的6个默认成员函数