【C++】---类和对象（中）默认成员函数 和 操作符重载

前言：

假如一个类中既没有成员变量也没有成员函数，那么这个类就是空类，空类并不是什么都没有，因为所有类都会生成如下6个默认成员函数：

一、构造函数

1、构造函数的定义及其特性

对于日期类对象，我们可能会忘记调用Init函数进行初始化，C++为了解决这个问题，引入构造函数进行初始化。

#include
using namespace std;
class Date
{
private:
	int _year;
	int _month;
	int _day;
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout 
	Date d1;
	d1.Init(2024, 2, 11);
	d1.Print();
	return 0;
}

private:
	int _year;
	int _month;
	int _day;
};
 
int main()
{
	Date d1;//调用编译器自动生成的默认构造函数
 
	return 0;
}

public:
    
	//1.无参默认构造函数：初始化对象
	Date()
	{
		_year = 2024;
		_month = 2;
		_day = 12;
	}
	
private:
	int _year;
	int _month;
	int _day;
};
 
int main()
{
	Date d1;
 
	return 0;
}

public:
    //2.带参全缺省默认构造函数：初始化对象
	Date(int year = 2024, int month = 2, int day= 12)
	{
		_year = year;
		_month = month;
		_day = day;
	}
 
private:
	int _year;
	int _month;
	int _day;
};
 
int main()
{
	Date d1;//调用带参默认构造函数
 
	return 0;
}

public:
 Time()
 {
 cout 
private:
 // 基本类型(内置类型)
 int _year;
 int _month;
 int _day;
 // 自定义类型
 Time _t;
};
int main()
{
 Date d;
 return 0;
}

private:
	int _year;
	int _month;
	int _day;
public:
	Date(int year)
	{
		_year = year;
	}
	~Date()
	{
		// 调用一次 析构函数 我就打印一次
		cout 
	// 局部域
	Date d4(4);
	static Date d5(5);
	static Date d10(10);
}
// 全局域
Date d6(6);
static Date d7(7);
Date d8(8);
static Date d9(9);
int main()
{
	// 局部域
	Date d1(1);
	Date d2(2);
	static Date d3(3);
	func();
	return 0;
}

private:
	int _year;
	int _month;
	int _day;
public:
	void Print()
	{
		cout 
		_year = year;
		_month = month;
		_day = day;
	}
	//拷贝构造函数
	//Date(Date d)// 错误写法 使用传值方式编译器直接报错，因为会引发无穷递归调用
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	// 析构函数
	~Date()
	{
	}
};
int main()
{
	Date d1(2024,2,12);
	Date d2(d1);
	d1.Print();
	d2.Print();
	return 0;
}

private:
	int _year;
	int _month;
	int _day;
public:
	void Print()
	{
		cout 
		_year = year;
		_month = month;
		_day = day;
	}
	// 析构函数
	~Date()
	{
		cout 
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
};
int main()
{
	Date d1(2024,2,16);// 调用构造函数
	Date d2(d1);// 调用拷贝构造函数，就是在定义对象的时候直接用拷贝构造函数
	// Date(&d2,Date& d1)
	d2.Print();
	return 0;
}

private:
	int _year;
	int _month;
	int _day;
public:
	void Print()
	{
		cout 
		_year = year;
		_month = month;
		_day = day;
	}
	拷贝构造函数
	Date(Date d)// 错误写法 使用传值方式编译器直接报错，因为会引发无穷递归调用
	//Date(const Date& d)
	//{
	//	_year = d._year;
	//	_month = d._month;
	//	_day = d._day;
	//}
	// 析构函数
	~Date()
	{
	}
};
int main()
{
	Date d1(2024,2,12);
	Date d2(d1);
	d1.Print();
	d2.Print();
	return 0;
}

public:
	//构造函数
	Date(int year = 2024, int month = 2, int day = 16)
	{
		_year = year;
		_month = month;
		_day = day;
	}
 
//成员变量公有
public:
	int _year;
	int _month;
	int _day;
};
 
//operator==运算符重载
bool operator==(Date x1, Date x2)
{
	return x1._year == x2._year
		&& x1._month == x2._month
		&& x1._day == x2._day;
}
 
int main()
{
	Date d1(2024, 2, 15);
	Date d2(2024, 2, 16);
 
    //两种调用方式：
	//1.可读性不强
    operator==(d1, d2);
 
    //2.当编译器看到==自定义类型，会去检查日期类有没有==的重载运算符，如果有重载会转换成operator==(d1, d2)去调用operator==函数
	d1 == d2;
 
	return 0;
}

private:
	int _year;
	int _month;
	int _day;
public:
	void Print()
	{
		cout 
		_year = year;
		_month = month;
		_day = day;
	}
	// 析构函数
	~Date()
	{
		cout 
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	 //赋值运算符重载
	// d1=d2   //d1.operator=(&d1,d2)
	Date& operator=(const Date& d) // void Date& operator=(&d1,const Date& d)
	{
		if (this != &d) // 对d取地址，判断this的值和d的地址是否相同，如果不是自己给自己赋值，才需要拷
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
};
int main()
{
	//Date d1(2024,2,16);// 调用构造函数
	//Date d2(d1);// 调用拷贝构造函数，就是在定义对象的时候直接用拷贝构造函数
	 Date(&d2,Date& d1)
	//d2.Print();
	Date d1(2024, 2, 16);
	d1.Print();
	Date d2;
	d2.Print();
	d2 = d1;
	d2.Print();
	return 0;
}

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

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

	Date d1(2024, 2, 16);
	Date d2(2024, 3, 16);
 
	cout 
	return (_year == d._year)
		&& (_month = d._month)
		&& (_day == d._day);
}