class Date
{
public:void Init(int year, int month, int day){_year = year;_month = month;_day = day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}
private:int _year;int _month;int _day;
};
int main()
{Date d1;d1.Init(2022, 7, 5);d1.Print();Date d2;d2.Init(2022, 7, 6);d2.Print();return 0;
}

class Date
{
public:// 1.無參構造函數Date(){}// 2.帶參構造函數Date(int year, int month, int day){_year = year;_month = month;_day = day;}private:int _year;int _month;int _day;};void TestDate(){Date d1; // 調用無參構造函數Date d2(2015, 1, 1); // 調用帶參的構造函數// 注意：如果通過無參構造函數創建對象時，對象后面不用跟括號，否則就成了函數聲明// 以下代碼的函數：聲明了d3函數，該函數無參，返回一個日期類型的對象// warning C4930: “Date d3(void)”: 未調用原型函數(是否是有意用變量定義的?)Date d3();}

class Date{public:/*// 如果用戶顯式定義了構造函數，編譯器將不再生成Date(int year, int month, int day){_year = year;_month = month;_day = day;}*/void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;};int main(){// 將Date類中構造函數屏蔽后，代碼可以通過編譯，因為編譯器生成了一個無參的默認構造函數// 將Date類中構造函數放開，代碼編譯失敗，因為一旦顯式定義任何構造函數，編譯器將不再生成// 無參構造函數，放開后報錯：error C2512: “Date”: 沒有合適的默認構造函數可用Date d1;return 0;}

class Time
{
public:Time()               {cout << "Time()" << endl;_hour = 0;_minute = 0;_second = 0;}private: int _hour;   int _minute; int _second;
};
class Date
{
private:// 基本類型(內置類型)int _year;int _month;int _day;// 自定義類型Time _t;
};
int main()
{Date d;return 0;
}

class Time
{
public:Time(){cout << "Time()" << endl;_hour = 0;_minute = 0;_second = 0;}
private:int _hour;int _minute;int _second;
};
class Date
{
private:// 基本類型(內置類型)int _year = 1970;int _month = 1;int _day = 1;// 自定義類型Time _t;
};
int main()
{Date d;return 0;
}

class Date
{
public:Date(){_year = 1900;_month = 1;_day = 1;}Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;
};
// 以下測試函數能通過編譯嗎？
void Test()
{Date d1;    
}

ypedef int DataType;
class Stack
{
public:Stack(size_t capacity = 3){_array = (DataType*)malloc(sizeof(DataType) * capacity);if (NULL == _array){perror("malloc申請空間失敗!!!");return;}_capacity = capacity;_size = 0;}void Push(DataType data){// CheckCapacity();_array[_size] = data;_size++;}// 其他方法...~Stack(){if (_array){free(_array);_array = NULL;_capacity = 0;_size = 0;}}
private:DataType* _array;int _capacity;int _size;
};
void TestStack()
{Stack s;s.Push(1);s.Push(2);
}

class Time
{
public:~Time(){cout << "~Time()" << endl;}
private:int _hour;int _minute;int _second;
};
class Date
{
private:// 基本類型(內置類型)int _year = 1970;int _month = 1;int _day = 1;// 自定義類型Time _t;
};
int main()
{Date d;return 0;
}
// 程序運行結束后輸出：~Time()
// 在main方法中根本沒有直接創建Time類的對象，為什么最后會調用Time類的析構函數？
// 因為：main方法中創建了Date對象d，而d中包含4個成員變量，其中_year, _month, 
_day三個是
// 內置類型成員，銷毀時不需要資源清理，最后系統直接將其內存回收即可；而_t是Time類對
象，所以在d銷毀時，要將其內部包含的Time類的_t對象銷毀，所以要調用Time類的析構函數。但是：
main函數
// 中不能直接調用Time類的析構函數，實際要釋放的是Date類對象，所以編譯器會調用Date
類的析構函
// 數，而Date沒有顯式提供，則編譯器會給Date類生成一個默認的析構函數，目的是在其內部
調用Time
// 類的析構函數，即當Date對象銷毀時，要保證其內部每個自定義對象都可以正確銷毀
// main函數中并沒有直接調用Time類析構函數，而是顯式調用編譯器為Date類生成的默認析
構函數
// 注意：創建哪個類的對象則調用該類的析構函數，銷毀那個類的對象則調用該類的析構函數

// 全局的operator==
class Date
{
public:Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}//private: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;
}
void Test()
{Date d1(2018, 9, 26);Date d2(2018, 9, 27);cout << (d1 == d2) << endl;
}

class Date
{
public:Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}// bool operator==(Date* this, const Date& d2)// 這里需要注意的是，左操作數是this，指向調用函數的對象bool operator==(const Date& d2){return _year == d2._year&& _month == d2._month&& _day == d2._day;}
private:int _year;int _month;int _day;
};

class Date
{ 
public :Date(int year = 1900, 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;}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 ;
};

class Date
{
public:Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}int _year;int _month;int _day;
};
// 賦值運算符重載成全局函數，注意重載成全局函數時沒有this指針了，需要給兩個參數
Date& operator=(Date& left, const Date& right)
{if (&left != &right){left._year = right._year;left._month = right._month;left._day = right._day;}return left;
}
// 編譯失敗：
// error C2801: “operator =”必須是非靜態成員

原因：賦值運算符如果不顯式實現，編譯器會生成一個默認的。此時用戶再在類外自己實現

一個全局的賦值運算符重載，就和編譯器在類中生成的默認賦值運算符重載沖突了，故賦值

運算符重載只能是類的成員函數。

3. 用戶沒有顯式實現時，編譯器會生成一個默認賦值運算符重載，以值的方式逐字節拷貝 。注

意：內置類型成員變量是直接賦值的，而自定義類型成員變量需要調用對應類的賦值運算符

重載完成賦值。

class Time
{
public:Time(){_hour = 1;_minute = 1;_second = 1;}Time& operator=(const Time& t){if (this != &t){_hour = t._hour;_minute = t._minute;_second = t._second;}return *this;}
private:int _hour;int _minute;int _second;
};
class Date
{
private:// 基本類型(內置類型)int _year = 1970;int _month = 1;int _day = 1;// 自定義類型Time _t;
};
int main()
{Date d1;Date d2;d1 = d2;return 0;
}

既然 編譯器生成的默認賦值運算符重載函數已經可以完成字節序的值拷貝了 ，還需要自己實

現嗎？當然像日期類這樣的類是沒必要的。那么下面的類呢？驗證一下試試？

// 這里會發現下面的程序會崩潰掉？這里就需要我們以后講的深拷貝去解決。
typedef int DataType;
class Stack
{
public:Stack(size_t capacity = 10){_array = (DataType*)malloc(capacity * sizeof(DataType));if (nullptr == _array){perror("malloc申請空間失敗");return;}_size = 0;_capacity = capacity;}void Push(const DataType& data){// CheckCapacity();_array[_size] = data;_size++;}~Stack(){if (_array){free(_array);_array = nullptr;_capacity = 0;_size = 0;}}
private:DataType* _array;size_t _size;size_t _capacity;
};
int main()
{Stack s1;s1.Push(1);s1.Push(2);s1.Push(3);s1.Push(4);Stack s2;s2 = s1;return 0;
}

注意：如果類中未涉及到資源管理，賦值運算符是否實現都可以；一旦涉及到資源管理則必

須要實現。

class Date
{
public:Date(int year, int month, int day){_year = year;_month = month;_day = day;}void Print(){cout << "Print()" << endl;cout << "year:" << _year << endl;cout << "month:" << _month << endl;cout << "day:" << _day << endl << endl;}void Print() const{cout << "Print()const" << endl;cout << "year:" << _year << endl;cout << "month:" << _month << endl;cout << "day:" << _day << endl << endl;}
private:int _year; // 年int _month; // 月int _day; // 日
};
void Test()
{Date d1(2022, 1, 13);  d1.Print(); const Date d2(2022, 1, 13); d2.Print();    
}

class Date{public:Date* operator&(){return this;}const Date* operator&()const{return this;}private:int _year; // 年int _month; // 月int _day; // 日};

友元

概念
友元提供了一種突破封裝的方式，有時提供了便利。但是友元會增加耦合度，破壞了封裝，所以 友元不宜多用。 友元分為：友元函數和友元類

友元函數

問題：現在嘗試去重載 operator<< ，然后發現沒辦法將 operator<< 重載成成員函數。 因為 cout 的

輸出流對象和隱含的 this 指針在搶占第一個參數的位置 。 this 指針默認是第一個參數也就是左操作

數了。但是實際使用中 cout 需要是第一個形參對象，才能正常使用。所以要將 operator<< 重載成

全局函數。但又會導致類外沒辦法訪問成員，此時就需要友元來解決。 operator>> 同理。

	class Date{public:Date(int year, int month, int day): _year(year), _month(month), _day(day){}// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常規調用
// 因為成員函數第一個參數一定是隱藏的this，所以d1必須放在<<的左側ostream& operator<<(ostream& _cout){_cout << _year << "-" << _month << "-" << _day << endl;return _cout;}private:int _year;int _month;int _day;};

class Date
{friend ostream& operator<<(ostream& _cout, const Date& d);friend istream& operator>>(istream& _cin, Date& d);
public:Date(int year = 1900, int month = 1, int day = 1): _year(year), _month(month), _day(day){}
private:int _year;int _month;int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{_cout << d._year << "-" << d._month << "-" << d._day;return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{_cin >> d._year;_cin >> d._month;_cin >> d._day;return _cin;
}
int main()
{Date d;cin >> d;cout << d << endl;return 0;
}

友元類

友元類的所有成員函數都可以是另一個類的友元函數，都可以訪問另一個類中的非公有成員。

友元關系是單向的，不具有交換性。

比如上述 Time 類和 Date 類，在 Time 類中聲明 Date 類為其友元類，那么可以在 Date 類中直接

訪問 Time 類的私有成員變量，但想在 Time 類中訪問 Date 類中私有的成員變量則不行。

友元關系不能傳遞

如果 C 是 B 的友元， B 是 A 的友元，則不能說明 C 時 A 的友元。

友元關系不能繼承，在繼承位置再給大家詳細介紹。