#include <iostream>
using namespace std;
class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//拷貝構(gòu)造函數(shù)
	//參數(shù)只有一個(gè)，必須是類類型對(duì)象的引用。
    //Date d2(d1); 
	Date(Date& d)   //傳引用，正確寫(xiě)法
	//Date(Date d)  //傳值，錯(cuò)誤寫(xiě)法
{
    //用來(lái)檢測(cè)是否調(diào)用該拷貝構(gòu)造函數(shù)
	cout << "Date(Date& d)" << endl;
	//d1是d的別名，隱含的this就是d2,相當(dāng)于把d1的值拷貝給d2
	_year = d._year;
	_month = d._month;
	_day = d._day;
}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;  // 年
	int _month; // 月
	int _day;   // 日
};
int main()
{
	Date d1(2024,4,21);
	d1.Print();
	//d2對(duì)象不在按指定年月日初始化，而是想和d1對(duì)象初始化一樣
	//拷貝構(gòu)造：用同類型的對(duì)象拷貝初始化
	Date d2(d1);//這句代碼也等價(jià)于Date d2 = d1;也是拷貝構(gòu)造的寫(xiě)法
	d2.Print();
	return 0;
}

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(Date& d)  
{
    //用來(lái)檢測(cè)是否調(diào)用該拷貝構(gòu)造函數(shù)
	cout << "Date(Date& d)" << endl;
	//d1是d的別名，隱含的this就是d2,相當(dāng)于把d1的值拷貝給d2
	_year = d._year;
	_month = d._month;
	_day = d._day;
}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;  // 年
	int _month; // 月
	int _day;   // 日
};
void func(Date d)
{
	d.Print();
}
int main()
{
	Date d1(2024, 4, 12);
	//調(diào)用func之前會(huì)先進(jìn)入拷貝構(gòu)造函數(shù)
	func(d1);
	return 0;
}

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(Date& d)  
{
    //用來(lái)檢測(cè)是否調(diào)用該拷貝構(gòu)造函數(shù)
	cout << "Date(Date& d)" << endl;
	//d1是d的別名，隱含的this就是d2,相當(dāng)于把d1的值拷貝給d2
	_year = d._year;
	_month = d._month;
	_day = d._day;
}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;  // 年
	int _month; // 月
	int _day;   // 日
};
void func(Date* d)
{
	d->Print();
}
int main()
{
	Date d1(2024, 4, 12);
	func(&d1);
	return 0;
}

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(Date& d)  
{
    //用來(lái)檢測(cè)是否調(diào)用該拷貝構(gòu)造函數(shù)
	cout << "Date(Date& d)" << endl;
	//d1是d的別名，隱含的this就是d2,相當(dāng)于把d1的值拷貝給d2
	_year = d._year;
	_month = d._month;
	_day = d._day;
}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;  // 年
	int _month; // 月
	int _day;   // 日
};
void func(Date& d)//d是d1的別名
{
	d.Print();
}
int main()
{
	Date d1(2024, 4, 12);
	//調(diào)用func之前會(huì)先進(jìn)入拷貝構(gòu)造函數(shù)
	func(d1);
	return 0;
}

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//用指針就不會(huì)形成無(wú)窮遞歸，但此時(shí)它就是一個(gè)普通構(gòu)造了，不是拷貝構(gòu)造。
	//感覺(jué)怪怪的，所以一般用引用
	Date(Date* d)
	{
	    _year = d->_year;
		_month = d->_month;
		_day = d->_day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;  // 年
	int _month; // 月
	int _day;   // 日
};
int main()
{
	Date d2(2024, 4, 21);
	Date d3(&d2);
	d3.Print();
	return 0;
}

class Time
{
public:
	Time()
	{
		_hour = 1;
		_minute = 1;
		_second = 1;
	}
	Time(const Time& t)
	{
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
		//檢測(cè)是否調(diào)用了這個(gè)拷貝構(gòu)造函數(shù)
		cout << "Time::Time(const Time&)" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	// 基本類型(內(nèi)置類型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	// 自定義類型
	Time _t;
};
int main()
{
	Date d1(2024, 4, 23);
	// 用已經(jīng)存在的d1拷貝構(gòu)造d2，此處會(huì)調(diào)用Date類的拷貝構(gòu)造函數(shù)
	// 但Date類并沒(méi)有顯式定義拷貝構(gòu)造函數(shù)，則編譯器會(huì)給Date類生成一個(gè)默認(rèn)的拷貝構(gòu)造函數(shù)
		Date d2(d1);
		d2.Print();
	return 0;
}

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申請(qǐng)空間失敗!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	//注意：如果沒(méi)有顯示寫(xiě)析構(gòu)函數(shù)，編譯器也會(huì)自動(dòng)生成。
	//自動(dòng)生成的析構(gòu)對(duì)內(nèi)置類型不做處理，自定義類型才會(huì)去調(diào)用它的析構(gòu)
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};
int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(1);
	st1.Push(1);
	Stack st2 = st1;
	return 0;
}

//實(shí)現(xiàn)棧的深拷貝
//Stack st2 = st1;  //st是st1的別名
Stack(const Stack& st)
{
	_array = (DataType*)malloc(sizeof(DataType) * st._capacity);
	if (NULL == _array)
	{
		perror("malloc申請(qǐng)空間失敗!!!");
		return;
	}
	//開(kāi)辟好空間后再把值拷貝進(jìn)去
	memcpy(_array, st._array, sizeof(DataType) * st._size);
	_size = st._size;
	_capacity = st._capacity;
}

class OB
{
public:
	void func()
	{
		cout << "void func()" << endl;
	}
};
//重新定義成員函數(shù)指針類型
//注意：typedef void(*)()  PtrFunc; 是錯(cuò)誤寫(xiě)法
typedef  void (OB::* PtrFunc)();
int main()
{
	//成員函數(shù)要加&才能取到函數(shù)指針
	PtrFunc fp = &OB::func; //定義成員函數(shù)指針fp 指向函數(shù)func
	OB tmp;//定義OB類對(duì)象tmp
	(tmp.*fp)(); //調(diào)用成員函數(shù)的指針
	return 0;
}

class Date
{
public:
	Date(int year , int month , int day )
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//d3.operator== (d4)
	//d3傳給了隱含的this指針，d是d4的別名
	 bool operator== (const Date & d)
	 {
		 return _year == d._year
			 && _month == d._month
			 && _day == d._day;
	 }
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;  // 年
	int _month; // 月
	int _day;   // 日
};
//但是如果全局重載（沒(méi)有private時(shí))和成員函數(shù)同時(shí)存在，編譯不會(huì)報(bào)錯(cuò)，
//調(diào)用時(shí)會(huì)默認(rèn)調(diào)成員函數(shù)，相當(dāng)于全局重載沒(méi)有任何意義了。
int main()
{
	Date d3(2024, 4, 12);
	Date d4(2024, 4, 15);
	//顯式調(diào)用(一般不這樣寫(xiě))
	//cout << d3.operator== (d4) << endl;
	//轉(zhuǎn)換調(diào)用 等價(jià)于d3.operator== (d4) 匯編代碼
	//注意：如果是兩個(gè)操作數(shù)，從左到右的參數(shù)是對(duì)應(yīng)的，不能顛倒位置
	cout << (d3 == d4) << endl;
	return 0;
}

class Date
{
public:
	Date(int year = 2024, int month = 4, int day = 21)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//拷貝構(gòu)造
	Date(const Date& d)
	{
		cout << "Date(const Date& d)" << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	//d1 = d3
	//void operator= (const Date& d)
	//{
	//	_year = d._year;
	//	_month = d._month;
	//	_day = d._day;
	//}
	//有時(shí)候會(huì)帶返回值:目的是為了連續(xù)拷貝
	//d1 = d2 = d3; 
	//比如這里，d是d3的別名，從右往左，先d2 = d3,返回值是d2
	Date& operator= (const Date& d)
	{
	    //檢測(cè)是否自己給自己賦值
	     if(this != &d)
	  {
			_year = d._year;
			_month = d._month;
			_day = d._day;
	  }
      //這里的d2的地址是this ，*this就是d2。
      //這里的*this才是對(duì)象本身，對(duì)象在main的作用域
      //里創(chuàng)建的，因此出main作用域才會(huì)析構(gòu)銷毀，
      //出了當(dāng)前函數(shù)不會(huì)析構(gòu)。所以可以用引用返回。
		return *this;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;  // 年
	int _month; // 月
	int _day;   // 日
};
int main()
{
	Date d1(2024, 4, 12);
	//拷貝構(gòu)造
	//一個(gè)已經(jīng)存在的對(duì)象，拷貝給另一個(gè)要?jiǎng)?chuàng)建初始化的對(duì)象
	Date d2 = d1;
	Date d3(2024, 5, 1);
	//賦值拷貝/賦值重載
	//一個(gè)已經(jīng)存在的對(duì)象，拷貝賦值給另一個(gè)已經(jīng)存在的對(duì)象
	//d1 = d3;
	//連續(xù)賦值
	d1 = d2 = d3;
	return 0;
}

class Date
{
public:
 Date(int year, int minute, int day)
   {
      cout << "Date(int,int,int):" << this << endl;
   }
 Date(const Date& d)
   {
      cout << "Date(const Date& d):" << this << endl;
   }
 ~Date()
   {
      cout << "~Date():" << this << endl;
   }
private:
	 int _year;
	 int _month;
	 int _day;
};
Date Test(Date d)
  {
	 Date temp(d);
	 return temp;
  }
int main()
  {
	 Date d1(2022,1,13);
	 Test(d1);
	 return 0;
  }