类和对象（万字总结！深度总结了类的相关知识）（中）

A obj; // 自动调用构造函数
A* ptr = new A(); // 自动调用构造函数

class A {
public:
   A() {
       // 默认构造函数
       std::cout << "Default constructor called" << std::endl;
   }
};

class A {
public:
   int x, y;
   A(int a, int b) : x(a), y(b) {
       std::cout << "Parameterized constructor called" << std::endl;
   }
};

class A {
public:
   A(const A& other) {
       std::cout << "Copy constructor called" << std::endl;
   }
};

class A {
public:
   A(A&& other) noexcept {
       std::cout << "Move constructor called" << std::endl;
   }
};

class A {
public:
	int x;
	const int y;
	A(int a, int b) : x(a), y(b) {  // 初始化列表
  		std::cout << "Constructor with initializer list called" << std::endl;
	}
};

class A {
public:
   ~A() {
       std::cout << "Destructor called" << std::endl;
   }
};

int main() {
   A obj; // 栈上对象，超出作用域时析构
   A* ptr = new A(); // 堆上对象
   delete ptr; // 显式调用析构函数
}

class A {
private:
   int* data;
public:
   A() {
       data = new int[10]; // 动态分配资源
   }
   ~A() {
       delete[] data; // 释放资源
       std::cout << "Destructor called" << std::endl;
   }
};

class A {
public:
	A(const A& other);  // 拷贝构造函数
};

A obj1;  // 默认构造函数
A obj2 = obj1;  // 调用拷贝构造函数

#include <iostream>
using namespace std;

class A {
public:
	int* data;

	// 构造函数
	A(int val) {
		data = new int(val);
		cout << "Constructor called, value: " << *data << endl;
	}

	// 拷贝构造函数（深拷贝）
	A(const A& other) {
		data = new int(*(other.data));  // 分配新内存，并复制数据
		cout << "Copy Constructor called, value: " << *data << endl;
	}

	// 析构函数
	~A() {
		delete data;
		cout << "Destructor called, value deleted" << endl;
	}
};

int main() {
	A obj1(10);        // 调用普通构造函数
	A obj2 = obj1;     // 调用拷贝构造函数（深拷贝）
	return 0;
}

Constructor called, value: 10
Copy Constructor called, value: 10
Destructor called, value deleted
Destructor called, value deleted

class ClassName {
public:
// 赋值运算符重载
	ClassName& operator=(const ClassName& other);
};

#include <iostream>
using namespace std;

class A {
public:
	int* data;

	// 构造函数
	A(int val) {
		data = new int(val);	// 动态分配内存，并用 val 初始化
		cout << "Constructor called, value: " << *data << endl;
	}

	// 拷贝构造函数（深拷贝）
	A(const A& other) {
		data = new int(*(other.data));
		cout << "Copy Constructor called, value: " << *data << endl;
	}

	// 赋值运算符重载（深拷贝）
	A& operator=(const A& other) {
		if (this == &other) {  // 自我赋值检查
			return *this;  // 如果是自我赋值，直接返回当前对象
		}

		delete data;  // 释放当前对象的已有资源
		data = new int(*(other.data));  // 分配新内存并复制数据
		cout << "Assignment Operator called, value: " << *data << endl;

		return *this;  // 返回当前对象的引用
	}

	// 析构函数
	~A() {
		delete data;	// 释放动态分配的内存
		cout << "Destructor called, value deleted" << endl;
	}
};

int main() {
	A obj1(10);        // 调用构造函数
	A obj2(20);        // 调用构造函数

	obj2 = obj1;       // 调用赋值运算符重载
	A obj3 = obj1;     // 调用拷贝构造函数

	return 0;
}

Constructor called, value: 10
Constructor called, value: 20
Destructor called, value deleted
Assignment Operator called, value: 10
Copy Constructor called, value: 10
Destructor called, value deleted
Destructor called, value deleted
Destructor called, value delete

obj1 = obj1;  // 自我赋值

A obj1(10), obj2(20), obj3(30);
obj3 = obj2 = obj1;  // 支持链式赋值

Date& operator+=(int days) {
	// 增加指定的天数
	for (int i = 0; i < days; ++i) {
		incrementDay();  // 增加一天
	}
	return *this;  // 返回当前对象的引用，以支持链式操作
}

Date operator+(int days) const {
	Date temp = *this;  // 创建当前对象的副本
	temp += days;       // 使用 `+=` 运算符增加天数
	return temp;        // 返回新的日期对象
}

Date& operator++() {
incrementDay();	 // 增加一天
return *this;	// 返回当前对象的引用
}

Date operator++(int) {
Date temp = *this; // 保存当前日期
incrementDay();
return temp; // 返回原日期
}

class Date {
  int year, month, day;
  // 以成员函数形式的流插入运算符重载
  std::ostream& operator<<(std::ostream& out) {
      out << year << "年" << month << "月" << day << "日";
      return out;
  }
};

#include<iostream>
using namespace std;

class Date {
  int year, month, day;
  // 以成员函数形式的流插入运算符重载

public:
  ostream& operator<<(std::ostream& out) {
      out << year << "年" << month << "月" << day << "日";
      return out;
  }
  Date(int year, int month, int day) : year(year), month(month), day(day) {}
};

int main()
{
  Date d(2023, 9, 9);
  // cout << d; // 这里左操作数是std::cout

  d << cout;  // 正确操作，但是与标准操作不符
  return 0;
}

class Date {
private:
	int year;
	int month;
	int day;

	friend ostream& operator<<(ostream& out, const Date& d)；
};

std::cin >> d1 >> d2;

#include <iostream>
#include <stdexcept>
using namespace std;

class Date {
private:
	int year;
	int month;
	int day;

	// 声明友元函数，方便外部重载的流插入与流提取函数访问私有成员变量 
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);

	// 检查是否是闰年
	bool isLeapYear(int year) const {
		return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
	}

// 检查日期是否合法
bool isValidDate(int year, int month, int day) const {
  if (month < 1 || month > 12) return false;
  if (day < 1 || day > daysInMonth(month, year)) return false;
  return true;
}

	// 获取指定月份的天数
	int daysInMonth(int month, int year) const {
		// 每个月的天数，2月在闰年时会有29天
		static const int daysInMonth[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
		if (month == 2 && isLeapYear(year)) {
			return 29; // 闰年2月有29天
		}
		return daysInMonth[month - 1]; // 返回非闰年的月份天数
	}

	// 将日期递增一天
	void incrementDay() {
		++day; // 天数加1
		if (day > daysInMonth(month, year)) { // 如果天数超出该月的天数
			day = 1; // 设为1号
			++month; // 月份加1
			if (month > 12) { // 如果月份超出12
				month = 1; // 设为1月
				++year; // 年份加1
			}
		}
	}

public:
	// 构造函数，初始化日期
	    Date(int year, int month, int day) : year(year), month(month), day(day) {
       if (!isValidDate(year, month, day)) 
      throw invalid_argument("Invalid date");
  }

	// 前置 ++ 运算符重载
	Date& operator++() {
		incrementDay(); // 递增一天
		return *this; // 返回当前对象的引用，以支持链式操作
	}

	// 后置 ++ 运算符重载
	Date operator++(int) {
		Date temp = *this; // 创建当前对象的副本
		incrementDay(); // 递增一天
		return temp; // 返回副本，表示递增前的日期
	}

	// += 运算符重载
	Date& operator+=(int days) {
		for (int i = 0; i < days; ++i) {
			incrementDay(); // 增加指定的天数
		}
		return *this; // 返回当前对象的引用，以支持链式操作
	}

	// + 运算符重载
	Date operator+(int days) const {
		Date temp = *this; // 创建当前对象的副本
		temp += days; // 使用 += 运算符增加天数
		return temp; // 返回新的日期对象
	}  
};    

// << 运算符重载    
ostream& operator<<(ostream& out, const Date& d)
{
	out << d.year << "年" << d.month << "月" << d.day << "日" << endl;
	return out;
}

// >> 运算符重载    
istream& operator>>(istream& in, Date& d)
{
	in >> d.year >> d.month >> d.day;
if (!d.isValidDate(d.year, d.month, d.day)) {
  in.setstate(ios::failbit); // 输入非法时设置错误标志
  throw invalid_argument("Invalid date input");
}
	return in;
}

// 测试
int main() {
	Date d(2024, 2, 28); // 创建一个日期对象
	cout << d; // 打印: 2024年2月28日

	++d; // 前置 ++ 操作
	cout << d;; // 打印: 2024年2月29日 (2024年是闰年)

	d++; // 后置 ++ 操作
	cout << d; // 打印: 2024年3月1日

	d += 30; // 增加30天
	cout << d; // 打印: 2024年3月31日

	Date d2 = d + 1; // 使用 + 运算符
	cout << d2; // 打印: 2024年4月1日

	cin >> d;	// 输入2005 3 20
	cout << d;	// 打印：2005年3月20日

	return 0;
}

const int day = 5;
day = 15;	// 错误，day是常量，不能被修改

// a拷贝给b，b的改变不影响a，不涉及权限放大问题
const int a = 10;
int b = a;

// b是a的别名，b的改变会影响a，设计权限放大
const int a = 10;
int& b = a;

// 跟引用类似，涉及权限放大
const int a = 10;
int* pb = &a;

class MyClass {
public:
  int getValue() const {  // 这是一个 const 成员函数
      return value;
  }

  void setValue(int val) {  // 非 const 成员函数
      value = val;
  }

private:
  int value;
};

int main() {
  const MyClass obj;  // 定义一个 const 对象
  obj.getValue();     // 只允许调用 const 成员函数
  // obj.setValue(5);  // 错误：不能调用非 const 成员函数
}

//日期类
class Date
{
public:
	//取地址重载
	Date* operator&()
	{
		return this;
	}
	//const修饰的取地址操作符重载，给const对象调用
	const Date* operator&() const
	{
		return this;
	}
private:
	int _year;
	int _month;
	int _day;
};