【C++】类和对象（中）_c++类中的属性会自动调用默认构造函数构造吗-优快云博客

本文链接：https://blog.youkuaiyun.com/t5y22/article/details/144043955

前言：如果一个类中什么成员都没有，我们简称其为空类。但是空类中真的什么都没有吗？其实不然，任何一个类，即使我们什么都不写，类中也会自动生成6个默认成员函数。

class Date {}; //空类

下面我们来介绍一下这些默认成员函数

一、构造函数

1、构造函数的概念

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

例如，以下日期类中的成员函数Date就是一个构造函数。当你用该日期类创建一个对象时，编译器会自动调用该构造函数对新创建的变量进行初始化：

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)// 构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

构造函数的主要任务并不是开空间创建对象，而是初始化对象。

2、构造函数的特性

1️⃣构造函数的函数名与类名相同

2️⃣构造函数无返回值
这里所说的构造函数无返回值是真的无返回值，而不是说返回值为void。

3️⃣对象实例化时编译器自动调用对应的构造函数
当你用类创建一个对象时，编译器会自动调用该类的构造函数对新创建的变量进行初始化。

4️⃣构造函数支持重载
这意味着你可以有多种初始化对象的方式，编译器会根据你所传递的参数去调用对应的构造函数。

5️⃣如果类中没有显示定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，若用户显示定义了，则编译器就不再生成

补充1：

无参的构造函数、全缺省的构造函数以及我们不写编译器自动生成的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
初学C++时，你可能认为只有当我们不写，编译器自动生成的构造函数才被称为默认构造函数。其实并不是这样的，以下3种都叫做默认构造函数：
1、我们不写，编译器自动生成的构造函数。
2、我们自己写的无参的构造函数。
3、我们自己写的全缺省的构造函数。
总而言之，无需传参就可以调用的构造函数就是默认构造函数

关于全缺省构造函数的小Tip：

一、首先明确全缺省构造函数的概念

全缺省构造函数是指构造函数的所有参数都有默认值。例如：
class MyClass {
public:
    MyClass(int a = 0, int b = 0) {
        this->a = a;
        this->b = b;
    }
private:
    int a;
    int b;
};
这里的MyClass构造函数就是全缺省构造函数，在类内定义时参数有默认值。

二、在类外定义全缺省构造函数的情况时

当在类外定义全缺省构造函数时，不需要再写参数的默认值。
例如，对于上面的MyClass类，在类外定义构造函数可以这样写：
MyClass::MyClass(int a, int b) {
    this->a = a;
    this->b = b;
}
因为默认值已经在类内的函数声明部分指定了，在类外定义函数体时，只需要按照正常的函数参数列表来定义即可。

在类外定义全缺省构造函数时不需要加上缺省值。不过要注意，这种规则是基于 C++ 语言的，不同的编程语言可能有不同的规定。

说到这里，你可能会想：既然在我们不写的情况下，编译器会自动生成一个构造函数，那我们就没有必要自己写构造函数了。这种想法是不对的。

看看以下代码：

#include <iostream>
using namespace std;
class Date
{
public:
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1; // 编译器将调用自动生成的默认构造函数对d1进行初始化
	d1.Print();
	return 0;
}

打印结果：

疑问：d1对象调用了编译器自动生成的构造函数后，d1对象的_year/_month/_day依旧是随机值，那这编译器自动生成的构造函数还有什么意义？

原因：

编译器自动生成的构造函数机制：
1、编译器自动生成的构造函数对内置类型不做处理。
2、对于自定义类型，编译器会再去调用它们自己的默认构造函数。

总结：

虽然在我们不写的情况下，编译器会自动生成构造函数，但是编译器自动生成的构造函数可能达不到我们想要的效果，所以大多数情况下都需要我们自己写构造函数。

二、析构函数

1、析构函数的概念

与构造函数功能相反，析构函数负责完成对象的清理，对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

我们知道当一个类对象销毁时，其中的局部变量也会随着该对象的销毁而销毁，例如，我们用日期类创建了一个对象d1，当d1被销毁时，对象d1当中的局部变量_year/_month/_day也会被编译器销毁。
但是这并不意味着析构函数没有什么意义。像栈(Stack)这样的类对象，当该对象被销毁时，其中动态开辟的栈并不会随之被销毁，需要我们对其进行空间释放，这时析构函数的意义就体现了。

2、析构函数的特性

1️⃣析构函数的函数名是在类名前加上字符‘~’

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

2️⃣析构函数无参数，无返回值
析构函数所谓的无返回值也是真的无返回值，而不是返回值为void。

3️⃣对象生命周期结束时，C++编译器会自动调用析构函数
这就大大降低了C语言中栈空间忘记释放问题的发生，因为当栈对象生命周期结束时，C++编译器会自动调用析构函数对其栈空间进行释放。

4️⃣一个类有且只有一个析构函数。若未显示定义系统会自动生成默认的析构函数

编译器自动生成的析构函数机制：
1、编译器自动生成的析构函数对内置类型不做处理。
2、对于自定义类型，编译器会再去调用它们自己的默认析构函数。

5️⃣先构造的后析构，后构造的先析构
因为对象是定义在函数中的，函数调用会建立栈帧，栈帧中的对象构造和析构也要符合先进后出的原则。

三、拷贝构造函数

1、拷贝构造函数函数的概念

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

#include <iostream>
using namespace std;
class Date
{
public:
	Date(int year = 0, 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(2021, 5, 31);
	Date d2(d1); // 用已存在的对象d1创建对象d2

	return 0;
}

2、拷贝构造函数的特性

1️⃣拷贝构造函数是构造函数的一个重载形式
因为拷贝构造函数的函数名也与类名相同。

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

如果使用传值传参，会发生如下情况：

要调用拷贝构造函数就需要先传参，若传参使用传值传参，那么在传参过程中又需要进行对象的拷贝构造，如此循环往复，最终引发无穷递归调用。

3️⃣若未显示定义拷贝构造函数，系统将生成默认的拷贝构造函数

#include <iostream>
using namespace std;
class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)// 构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2021, 5, 30);
	Date d2(d1); // 用已存在的对象d1创建对象d2
	d1.Print();
	d2.Print();
	return 0;
}

结果：

原因：

代码中，我们自己并没有定义拷贝构造函数，但编译器自动生成的拷贝构造函数最终还是完成了对象的拷贝构造。

系统生成的默认拷贝构造函数机制：

对于内置类型，值拷贝；

对于自定义类型，调用自定义类型自身的默认拷贝构造。

四、运算符重载

1、运算符重载的概念

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，其目的就是让自定义类型可以像内置类型一样可以直接使用运算符进行操作。

d1 == d2;// 可读性高（书写简单）
IsSame(d1, d2);// 可读性差（书写麻烦）

运算符重载函数也具有自己的返回值类型，函数名字以及参数列表。其返回值类型和参数列表与普通函数类似。
运算符重载函数名为：关键字operator后面接需要重载的操作符符号。

函数原型：返回值 operator运算符(参数列表)

注意：
1.不能通过连接其他符号来创建新的操作符：比如operator@。

2.重载操作符必须有一个类类型或枚举类型的操作数。

3.用于内置类型的操作符，重载后其含义不能改变。

4.作为类成员的重载函数时，函数有一个默认的形参this，限定为第一个形参。

5.不能重载的五个运算符

这里以重载 == 运算符作为例子：
我们可以将该运算符重载函数作为类的一个成员函数，此时该函数的第一个形参默认为this指针。

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
	bool operator==(const Date& d)// 运算符重载函数
	{
		return _year == d._year
			&&_month == d._month
			&&_day == d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};

我们也可以将该运算符重载函数放在类外面，但此时外部无法访问类中的成员变量，这时我们可以将类中的成员变量设置为共有(public)，这样外部就可以访问该类的成员变量了（也可以用友元函数解决该问题）。并且在类外没有this指针，所以此时函数的形参我们必须显示的设置两个。

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
	int _year;
	int _month;
	int _day;
};
bool operator==(const Date& d1, const Date& d2)// 运算符重载函数
{
	return d1._year == d2._year
		&&d1._month == d2._month
		&&d1._day == d2._day;
}

2、赋值运算符重载

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)// 构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date& operator=(const Date& d)// 赋值运算符重载函数
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
	void Print()// 打印函数
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

重载赋值运算符需要注意以下几点：

一、参数类型设置为引用，并用const进行修饰

赋值运算符重载函数的第一个形参默认是this指针，第二个形参是我们赋值运算符的右操作数。
由于是自定义类型传参，我们若是使用传值传参，会额外调用一次拷贝构造函数，所以函数的第二个参数最好使用引用传参（第一个参数是默认的this指针，我们管不了）。
其次，第二个参数，即赋值运算符的右操作数，我们在函数体内不会对其进行修改，所以最好加上const进行修饰。二、函数的返回值使用引用返回

二、函数的返回值使用引用返回

实际上，我们若是只以d2 = d1这种方式使用赋值运算符，赋值运算符重载函数就没必要有返回值，因为在函数体内已经通过this指针对d2进行了修改。但是为了支持连续赋值，即d3 = d2 = d1，我们就需要为函数设置一个返回值了，而且很明显，返回值应该是赋值运算符的左操作数，即this指针指向的对象。
和使用引用传参的道理一样，为了避免不必要的拷贝，我们最好还是使用引用返回，因为此时出了函数作用域this指针指向的对象并没有被销毁，所以可以使用引用返回。

三、赋值前检查是否是给自己赋值

若是出现d1 = d1，我们不必进行赋值操作，因为自己赋值给自己是没有必要进行的。所以在进行赋值操作前可以先判断是否是给自己赋值，避免不必要的赋值操作。

四、引用返回的是*this

赋值操作进行完毕时，我们应该返回赋值运算符的左操作数，而在函数体内我们只能通过this指针访问到左操作数，所以要返回左操作数就只能返回*this。

五、一个类如果没有显示定义赋值运算符重载，编译器也会自动生成一个，完成对象按字节序的值拷贝

没错，赋值运算符重载编译器也可以自动生成，并且也是支持连续赋值的。但是编译器自动生成的赋值运算符重载完成的是对象按字节序的值拷贝，例如d2 = d1，编译器会将d1所占内存空间的值完完全全地拷贝到d2的内存空间中去，类似于memcpy。
对于日期类，编译器自动生成的赋值运算符重载函数就可以满足我们的需求，我们可以不用自己写。但是这也不意味着所有的类都不用我们自己写赋值运算符重载函数，当遇到一些特殊的类，我们还是得自己动手写赋值运算符函数的。

注意区别以下代码所调用的函数：

	Date d1(2021, 6, 1); //构造
	Date d2(d1);  //拷贝构造
	Date d3 = d1;  //拷贝构造

    Date d4;
    d4=d1;  //赋值重载

注意区分拷贝构造函数和赋值运算符重载函数的使用场景：
拷贝构造函数：用一个已经存在的对象去构造初始化另一个即将创建的对象。
赋值运算符重载函数：在两个对象都已经存在的情况下，将一个对象赋值给另一个对象。

五、const关键字

1、const修饰类的成员函数

我们将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰的是类成员函数隐含的this指针，表明在该成员函数中不能对this指针指向的对象进行修改。

例如，我们可以对类成员函数中的打印函数进行const修饰，避免在函数体内不小心修改了对象：

	void Print()const// cosnt修饰的打印函数
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}

思考（经典面试题）：
1.const对象可以调用非const成员函数吗？
2.非const对象可以调用const成员函数吗？
3.const成员函数内可以调用其他的非const成员函数吗？
4.非cosnt成员函数内可以调用其他的cosnt成员函数吗？

答案：不可以、可以、不可以、可以

解释如下：
1.不可以。非const成员函数，即成员函数的this指针没有被const所修饰，我们传入一个被const修饰的对象，用没有被const修饰的this指针进行接收，属于权限的放大，函数调用失败。
2.可以。const成员函数，即成员函数的this指针被const所修饰，我们传入一个没有被const修饰的对象，用被const修饰的this指针进行接收，属于权限的缩小，函数调用成功。
3.不可以。在一个被const所修饰的成员函数中调用其他没有被const所修饰的成员函数，也就是将一个被const修饰的this指针的值赋值给一个没有被const修饰的this指针，属于权限的放大，函数调用失败。
4.可以。在一个没有被const所修饰的成员函数中调用其他被const所修饰的成员函数，也就是将一个没有被const修饰的this指针的值赋值给一个被const修饰的this指针，属于权限的缩小，函数调用成功。

2、取地址与const取地址操作符重载

取地址操作符重载和const取地址操作符重载，这两个默认成员函数一般不用自己重新定义，使用编译器自动生成的就行了：

class Date
{
public:
	Date* operator&()// 取地址操作符重载
	{
		return this;
	}
	const Date* operator&()const// const取地址操作符重载
	{
		return this;
	}
private:
	int _year;
	int _month;
	int _day;
};

六、日期类的实现

1、构造函数

2、打印函数

3、日期+=天数

4、日期+天数

5、日期-=天数

6、日期-天数

7、前置++

8、后置++

9、前置--

10、后置--

11、日期类的大小关系比较

12、日期类-日期类

日期 - 日期，即计算传入的两个日期相差的天数。我们只需要让较小的日期的天数一直加一，直到最后和较大的日期相等即可，这个过程中较小日期所加的总天数便是这两个日期之间差值的绝对值。若是第一个日期大于第二个日期，则返回这个差值的正值，若第一个日期小于第二个日期，则返回这个差值的负值

代码中使用flag变量标记返回值的正负，flag为1代表返回的是正值，flag为-1代表返回的是负值，最后返回总天数与flag相乘之后的值即可。

class Date

{

public:

	// 获取某年某月的天数

	int GetMonthDay(int year, int month);



	// 全缺省的构造函数

	Date(int year = 1900, int month = 1, int day = 1);



	// 拷贝构造函数

  // d2(d1)

	Date(const Date& d);



	// 赋值运算符重载

  // d2 = d3 -> d2.operator=(&d2, d3)

	Date& operator=(const Date& d);



	//// 析构函数

	//~Date();



	//// 日期+=天数

	Date& operator+=(int day);



	//// 日期+天数

	Date operator+(int day);



	//// 日期-天数

	Date operator-(int day);



	//// 日期-=天数

	Date& operator-=(int day);



	//// 前置++

	Date& operator++();



	//// 后置++

	Date operator++(int);



	//// 后置--

	Date operator--(int);



	//// 前置--

	Date& operator--();



	// >运算符重载

	bool operator>(const Date& d);



	// ==运算符重载

	bool operator==(const Date& d);



	// >=运算符重载

	bool operator >= (const Date& d);



	// <运算符重载

	bool operator < (const Date& d);



	// <=运算符重载

	bool operator <= (const Date& d);



	// !=运算符重载

	bool operator != (const Date& d);



	// 日期-日期 返回天数

	int operator-(const Date& d);

	//打印
	void Print();

private:

	int _year;

	int _month;

	int _day;

};

int Date::GetMonthDay(int year, int month)
{
	//创建一个静态数组，储存每年每月一般天数
	static int nums[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	int day = nums[month];

	//特殊情况处理：闰年2月
	if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
		day = 29;

	return day;
}


Date::Date(int year , int month, int day )
{
	_year = year;
	_month = month;
	_day = day;
}

Date::Date(const Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

Date& Date:: operator=(const Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;

	return *this;
}

void Date:: Print()
{
	cout << _year <<" " << _month << " " << _day << endl;
}


Date&  Date::operator+=(int day)
{
	//day<0

	//day>0
	_day += day;
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		_month++;

		if (_month > 12)
		{
			_year++;
			_month = 1;
		}
	}

	return *this;
}


Date Date::operator+(int day)
{
	Date tmp(*this);
	tmp += day;
	return tmp;
}


Date& Date::operator-=(int day)
{
	//day<0

	//day>0
	_day -= day;
	while (_day <= 0)
	{
		_month--;

		if (_month == 0)
		{
			_year--;
			_month = 12;
		}

		_day += GetMonthDay(_year, _month);

	}
	return *this;
}


Date Date::operator-(int day)
{
	Date tmp(*this);
	tmp -= day;
	return tmp;
}

//前置++
Date& Date::operator++()
{
	*this += 1;
	return *this;
}

//后置++
Date Date::operator++(int)
{
	Date tmp(*this);
	*this += 1;
	return tmp;
}

//后置
Date Date::operator--(int)
{
	Date tmp(*this);
	*this -= 1;
	return tmp;

}

//前置
Date& Date::operator--()
{
	*this -= 1;
	return *this;
}

// >运算符重载

bool Date::operator>(const Date& d)
{
	if (_year > d._year)

	{

		return true;

	}

	else if (_year == d._year)

	{

		if (_month > d._month)

		{

			return true;

		}

		else if (_month == d._month)

		{

			if (_day > d._day)

			{

				return true;

			}

		}
	}



	return false;
}

// ==运算符重载

bool Date::operator==(const Date& d)
{

	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}



// >=运算符重载

bool Date::operator >= (const Date& d)
{
	return *this > d || *this == d;
}



// <运算符重载

bool Date::operator < (const Date& d)
{
	return !(*this >= d);
}



// <=运算符重载

bool Date::operator <= (const Date& d)
{
	return !(*this > d);
}



// !=运算符重载

bool Date::operator != (const Date& d)
{
	return !(*this == d);
}



// 日期-日期 返回天数

int Date::operator-(const Date& d)
{
	int flag = 1;
	Date max = *this;
	Date min = d;
	//如果*this >= d , flag=1,不用调整
	//如果*this<d , flag=-1，需要调整
	if (*this < d)
	{
		flag = -1;
		max = d;
		min = *this;
	}
	int count = 0;
	while (min != max)
	{
		count++;
		min++;
	}
	return count * flag;
}

原文链接：https://blog.youkuaiyun.com/chenlong_cxy/article/details/117307465