C++类与对象深入之运算符重载与const及初始化列表详解

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;
	}
	int GetYear(){
		return _year;
	}
	int GetMonth(){
		return _month;
	}
	int GetDay(){
		return _day;
	}
private:
	int _year;
	int _month;
	int _day;
};
bool operator==( Date& d1,  Date& d2)
{
	return d1.GetYear() == d2.GetYear()
		&& d1.GetMonth() == d2.GetMonth()
		&& d1.GetDay() == d2.GetDay();
}
int main(){
	Date d1(2022, 5, 16);
	Date d2(2022, 5, 16);
	if (operator==(d1, d2)){
		cout << "==" << endl;
	}
	if (d1 == d2){ // 编译器会处理成对应重载运算符调用 if (operator==(d1, d2)){
		cout << "==" << endl;
	}
	system("pause");
	return 0;
}

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;
	}
	bool operator==(const Date& d)
	{
		return _year == d._year
			&& _month == d._month
			&& _day == d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2022, 5, 16);
	Date d2(2022, 5, 16);
	if (d1.operator==(d2)){
		cout << "==" << endl;
	}
	if (d1 == d2){ // 编译器会处理成对应重载运算符调用 if (d1.operator==(d2))
		cout << "==" << endl;
	}
	system("pause");
	return 0;
}

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;
	}
	// d2 = d1; -> d2.operator=(&d2, d1)
	// d1 = d1
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2022, 5, 16);
	Date d2;
	Date d3(d1); // 拷贝构造  -- 一个存在的对象去初始化另一个要创建的对象
	d2 = d1;     // 赋值重载/复制拷贝 -- 两个已经存在对象之间赋值
	d1 = d1;
	system("pause");
	return 0;
}

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;
	}
	bool operator<(const Date& d){
	if ((_year < d._year)
	|| (_year == d._year && _month < d._month)
	|| (_year == d._year && _month == d._month && d._day < d._day))
	{
	return true;
	}
	else{
	return false;
	}
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2022, 4, 16);
	Date d2(2022, 5, 16);
	if (d1 < d2){ // 编译器会处理成对应重载运算符调用 if (d1.operator<(d2))
		cout << "<" << endl;
	}
	system("pause");
	return 0;
}
<
请按任意键继续. . .

void Func(const Date& d)
{
	d.Print(); // d.Print(&d); -> const Date*   
	//传的是一个指针指向的内容不可以改变的指针，
	//而单纯的this指针是指向不可以改变，所以权限放大了  必须在Print函数后加const，把this指针权限进一步放小
	cout << &d << endl;
}
void TestDate3()
{
	Date d1(2022, 5, 18);
	d1.Print(); // d1.Print(&d1); -> Date* 
	Func(d1);
	cout << &d1 << endl;
}

	class Date
{
public:
	// 友元函数
	friend std::ostream& operator<<(std::ostream& out, const Date& d);
	friend std::istream& operator>>(std::istream& out, Date& d);
	//........
}

std::ostream& operator<<(std::ostream& out, const Date& d)
{
	out << d._year << "-" << d._month << "-" << d._day << endl;
	return out;
}
std::istream& operator>>(std::istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

class Person {
public:
	Person(int a, int b, int c) {
		m_A = a;
		m_B = b;
		m_C = c;
	}
private:
	int m_A;
	int m_B;
	int m_C;
};
int main() {
	Person p(1, 2, 3);
	system("pause");
	return 0;
}

class Person {
public:
	//初始化列表方式初始化
	Person(int a, int b, int c) 
		: m_A(a)
		, m_B(b)
		, m_C(c) 
	{}
private:
	int m_A;
	int m_B;
	int m_C;
};
int main() {
	Person p(1, 2, 3);
	system("pause");
	return 0;
}

int value = 10;
class A
{
public:
	A(int x)
		:_x(x)
	{}①
	/*A(int x = 0)
		:_x(x)
	{}*/②
private:
	int _x;
};
class Date
{
public:
	Date(int year, int n, int a)
		:_n(n)
		, _ref(value)
		,_aa(a)//①：当自定义类型没提供默认构造时，就在想用我们提供的值去初始化的时候，就在这里显式的去调用它的构造函数
		//如果有对应的默认构造，就不用写这行。不在初始化列表初始化，自动调用默认构造函数初始化
	{
		_year = year;
		//如果不在初始化列表初始化 ，但是我们还想去改变里面变量的值，只能这么玩
		//A aa(a);  调用默认构造 ②
		//_aa = aa;//赋值  这里使用了默认提供的赋值运算符重载？   这种方式麻烦  就用下面这种好
	}
private:
	int _year; // 声明
	const int _n;
	int& _ref;
	A _aa;
};
int main()
{
	Date d1(2022, 5, 20); // 对象定义
	system("pause");
	return 0;
}

int value = 10;
class A
{
public:
	A(int x)
		:_x(x)
	{}
private:
	int _x;
};
class Date
{
public:
	Date(int year, int n, int a)
		:_n(n)
		, _ref(value)
		, _year(year)
		, _aa(a)//当自定义类型没提供默认构造时，就在这里显式的去调用它的构造函数
	{}
	//总结：建议尽量在初始化列表初始化
private:
	int _year; // 声明
	const int _n;
	int& _ref;
	A _aa;
};
int main()
{
	Date d1(2022, 5, 20); // 对象定义
	system("pause");
	return 0;
}

int value = 10;
class A
{
public:
	A(int x = 10)//全缺省默认构造
		:_x(x)
	{}
private:
	int _x;
};
class Date
{
public:
	Date(int year, int n, int a)
		:_n(n)
		, _ref(value)
		, _year(year)
		//, _aa(a)  这时候我们在A类中提供了全缺省的默认构造函数，就可以不写这行代码
	{}
private:
	int _year; // 声明
	const int _n;
	int& _ref;
	A _aa;
};
int main()
{
	Date d1(2022, 5, 20); // 对象定义
	system("pause");
	return 0;
}

class Stack
{
public:
	Stack(int capacity = 0)
	{
		_a = (int*)malloc(sizeof(int)*capacity);
		_top = 0;
		_capacity = capacity;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
class MyQueue
{
public:
	MyQueue(int size = 100)
		:_size(size)//如果这里什么都没写，那么默认初始化列表就表示_st1就调用_st1的默认构造，_st2同理，
		//_size如果给了缺省值，就用缺省值初始化，没给就是随机值，
		//如果显式(int size = 1)、_size(size)写了  就用显式的这个值初始化
	{}
private:
	Stack _st1;
	Stack _st2;
	size_t _size = 1000; // 缺省值  如果上面哪个地方给了缺省参数，这里的这个缺省值也没用了
};
int main()
{
	MyQueue mq;
	return 0;
}

class Stack
{
public:
	Stack(int capacity = 0)
	{
		_a = (int*)malloc(sizeof(int)*capacity);
		_top = 0;
		_capacity = capacity;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
class MyQueue
{
public:
	MyQueue(int size = 100)
		//:_size(size)//如果这里什么都没写，那么默认初始化列表就表示_st1就调用_st1的默认构造，_st2同理，
		//_size如果给了缺省值，就用缺省值初始化，没给就是随机值，
		//如果显式(int size = 1)、_size(size)写了  就用显式的这个值初始化
	{}
private:
	Stack _st1;
	Stack _st2;
	size_t _size = 1000; // 缺省值  如果上面哪个地方给了缺省参数，这里的这个缺省值也没用了
};
int main()
{
	MyQueue mq;
	return 0;
}

class Stack
{
public:
	Stack(int capacity = 0)
	{
		_a = (int*)malloc(sizeof(int)*capacity);
		_top = 0;
		_capacity = capacity;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
class MyQueue
{
public:
	MyQueue(int size = 100)
		:_size(size)
	{}
private:
	Stack _st1;
	Stack _st2;
	size_t _size = 1000; 
};
int main()
{
	MyQueue mq(10);
	return 0;
}

class Stack
{
public:
	Stack(int capacity = 0)
	{
		_a = (int*)malloc(sizeof(int)*capacity);
		_top = 0;
		_capacity = capacity;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
class MyQueue
{
public:
	MyQueue(int size)
		:_size(size)
	{}
private:
	Stack _st1;
	Stack _st2;
	size_t _size = 1000; 
};
int main()
{
	MyQueue mq(10);
	return 0;
}

class Stack
{
public:
	Stack(int capacity = 0)
	{
		_a = (int*)malloc(sizeof(int)*capacity);
		_top = 0;
		_capacity = capacity;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
class MyQueue
{
public:
	MyQueue(int size = 100)
	{}
private:
	Stack _st1;
	Stack _st2;
	size_t _size = 1000; 
};
int main()
{
	MyQueue mq(10);
	return 0;
}

class Date
{
public:
	/*explicit Date(int year)
	:_year(year)
	{
	cout << "Date(int year)" << endl;
	}*/
	Date(int year)
		:_year(year)
	{
		cout << "Date(int year)" << endl;
	}
private:
	int _year;
};
int main()
{
	Date d2 = 2022; // 构造 + 拷贝构造 -》 优化 合二为一
	system("pause");
	return 0;
}

class Date
{
public:
	explicit Date(int year)
	:_year(year)
	{
	cout << "Date(int year)" << endl;
	}
private:
	int _year;
};
int main()
{
	//Date d1(2022); // 构造
	Date d2 = 2022; // 构造 + 拷贝构造 -》 优化 合二为一
	//Date& d6 = 2022;//一开始就说了对常数取别名要加const
	//const Date& d6 = 2022;//整型2022被不同类型区别名时，前面就说了，临时变量具有常性，此时是引用的2022的临时变量的别名
	system("pause");
	return 0;
}

class Date
{
public:
	explicit Date(int year)
	:_year(year)
	{
	cout << "Date(int year)" << endl;
	}
private:
	int _year;
};
int main()
{
	const Date& d6 = 2022;//整型2022被不同类型区别名时，前面就说了，临时变量具有常性，此时是引用的2022的临时变量的别名
	system("pause");
	return 0;
}