類和對象<上>

面向?qū)ο?/p>

一直以來都是面向過程編程比如C語言，直到七十年代面向過程編程在開發(fā)大型程序時表現(xiàn)出不足，計算機(jī)界提出了面向?qū)ο笏枷耄∣bject Oriented Programming），其中核心概念是類和對象，面向?qū)ο笕筇匦允欠庋b、繼承和多態(tài)。

面向過程和面向?qū)ο笾皇怯嬎銠C(jī)編程中兩種側(cè)重點不同的思想，面向過程算是一種最為實際的思考方式，其中重要的是模塊化的思想，面向過程更注重過程、動作或者說事件的步驟。就算是面向?qū)ο笠彩呛忻嫦蜻^程的思想，對比面向過程，面向?qū)ο蟮姆椒ㄖ饕前咽挛锝o對象化，認(rèn)為事物都可以轉(zhuǎn)化為一系列對象和它們之間的關(guān)系，更符合人對事物的認(rèn)知方式。

用外賣系統(tǒng)舉例，面向過程思想就會將訂餐、取餐、送餐、接單等等步驟模塊化再一個一個實現(xiàn)，體現(xiàn)到程序中就是一個個的函數(shù)。面向?qū)ο笏枷霑⒄麄€流程歸結(jié)為對象和對象間的關(guān)系，也就是商家、騎手和用戶三者和他們的關(guān)系，體現(xiàn)到程序中就是類的設(shè)計。

面向?qū)ο笫且粋€廣泛而深刻的思想，不可能一時半會就理解透徹，需要再學(xué)習(xí)和工作中慢慢體會。

C++不像Java是純面向?qū)ο笳Z言，C++基于面向?qū)ο蟮旨嫒軨所以也可以面向過程。

1. 類的定義

//C
struct Student {
	char name[20];
	int age;
	int id;
};
struct Student s;
strcpy(s.name, "yyo");
s.age = 18;
s.id = 11;
//C++
struct Student {
	//成員變量
	char _name[20];
	int _age;
	int _id;
	//成員方法
	void Init(const char* name, int age, int id) {
		strcpy(_name, name);
		_age = age;
		_id = id;
	}
	void Print() {
		cout << _name << endl;
		cout << _age << endl;
		cout << _id << endl;
	}
};
s1.Init("yyo", 19, 1);
s1.Print();
s2.Init("yyx", 18, 2);
s2.Print();

從上述代碼可以看出，在C語言中，結(jié)構(gòu)體中只能定義變量，就相當(dāng)于是個多個變量的集合，而且操作成員變量的方式相較于C++更加繁瑣且容易出現(xiàn)錯誤。

由于C++兼容C，故C++中定義類有兩個關(guān)鍵字分別是struct和class，結(jié)構(gòu)體在C++中也升級成了類，類名可以直接作類型使用。類與結(jié)構(gòu)體不同的地方在于，類中不僅可以定義變量，還可以定義方法或稱函數(shù)。

C++中更多用class定義類，用class定義的類和struct定義的類在訪問限定權(quán)限上稍有不同。

class className {
    // ...
};

class是類的關(guān)鍵字，className是類的名字，{}中的內(nèi)容是類體。類中的元素即變量和函數(shù)都叫類的成員，其中類的成員變量稱為類的屬性或是類的數(shù)據(jù)，類的函數(shù)成為類的方法或成員函數(shù)。

2. 類的封裝

面向?qū)ο缶幊讨v究個“封裝”二字，封裝體現(xiàn)在兩方面，一是將數(shù)據(jù)和方法都放到類中封裝起來，二是給成員增加訪問權(quán)限的限制。

2.1 訪問限定修飾符

C++共有三個訪問限定符，分別為公有public，保護(hù)protect，私有private。

• public修飾的成員可以在類外直接訪問，private和protect修飾的成員在類外不能直接訪問。
• class類中成員默認(rèn)訪問權(quán)限為private，struct類中默認(rèn)為public。
• 從訪問限定符出現(xiàn)的位置到下一個訪問限定符出現(xiàn)的位置之間都是該訪問限定符的作用域。

和public相比，private和protect在這里是類似的，它二者具體區(qū)別會在之后的繼承中談到。封裝的意義就在于規(guī)范成員的訪問權(quán)限，放開struct類的權(quán)限是因為要兼容C。

封裝的意義就在于規(guī)范成員的訪問權(quán)限，更好的管理類的成員，一般建議是將成員的訪問權(quán)限標(biāo)清楚，不要用類的默認(rèn)規(guī)則。

class Student {
private:
	//成員變量
	char _name[20];
	int _age;
	int _id;
public:
	//成員方法
	void Init(const char* name, int age, int id) {
		strcpy(_name, name);
		_age = age;
		_id = id;
	}
	void Print() {
		cout << _name << endl;
		cout << _age << endl;
		cout << _id << endl;
	}
};

注意，訪問限定修飾符只在編譯階段起作用，之后不會對變量和函數(shù)造成任何影響。

2.2 類的封裝

面向?qū)ο笕筇匦允欠庋b、繼承和多態(tài)。類和對象的學(xué)習(xí)階段，只強(qiáng)調(diào)類和對象的封裝機(jī)制。封裝的定義是：將數(shù)據(jù)和操作數(shù)據(jù)的方法放到類中有機(jī)結(jié)合，對外隱藏對象的屬性和實現(xiàn)細(xì)節(jié)，僅公開交互的接口。

封裝的本質(zhì)是一種管理機(jī)制。對比C語言版的數(shù)據(jù)結(jié)構(gòu)實現(xiàn)可以看到，沒有封裝并將結(jié)構(gòu)的成員全部暴露出來是危險的且容易出錯，但調(diào)用結(jié)構(gòu)提供的接口卻不易出錯。一般不允許輕易的操作在函數(shù)外操作和改變結(jié)構(gòu)，這便是封裝的好處。面向過程只有針對函數(shù)的封裝，而面向?qū)ο缶幊烫岢隽烁尤娴姆庋b機(jī)制，使得代碼更加安全且易于操作。

class Stack {
public:
	void Init();
	void Push(STDataType x);
	void Pop();
	STDataType Top();
	int Size();
	bool Empty();
	void Destroy();
private:
	STDataType* _a;
	int _top;
	int _capacity;
};

3. 類的使用

3.1 類的作用域

類定義了一個新的作用域，類中所有成員都在類的作用域中。

• 若直接在類內(nèi)定義函數(shù)體，編譯器默認(rèn)將類內(nèi)定義的函數(shù)當(dāng)作內(nèi)聯(lián)函數(shù)處理，在滿足內(nèi)聯(lián)函數(shù)的要求的情況下。
• 在類外定義成員函數(shù)時，需要使用域作用限定符::指明該成員歸屬的類域。如圖所示：

一般情況下，更多是采用像數(shù)據(jù)結(jié)構(gòu)時期那樣，聲明和定義分離的方式。

3.2 類的實例化

用類創(chuàng)建對象的過程，就稱為類的實例化。

1. 類只是一個“模型”，限定了類的性質(zhì)，但并沒有為其分配空間。
2. 由類可以實例化得多個對象，對象在內(nèi)存中占據(jù)實際的空間，用于存儲類成員變量。

類和對象的關(guān)系，就與類型和變量的關(guān)系一樣，可以理解為圖紙和房子的關(guān)系。

4. 類對象的存儲

既然類中既有成員變量又有成員函數(shù)，那么一個類的對象中包含了什么？類對象如何存儲？

class Stack {
public:
	void Init();
	void Push(int x);
	// ...
private:
	int* _a;
	int _top;
	int _capacity;
};
Stack st;
cout << sizeof(Stack) << endl;
cout << sizeof(st) << endl;

如果類成員函數(shù)也存放在對象中，實例化多個對象時，各個對象的成員變量相互獨立，但成員函數(shù)是相同的，相同的代碼存儲多份浪費空間。因此，C++對象中僅存儲類變量，成員函數(shù)存放在公共代碼段。

類的大小就是該類中成員變量之和，要求內(nèi)存對齊，和結(jié)構(gòu)體一樣。注意，空類的大小為1個字節(jié)，用來標(biāo)識這個對象的存在。

空類的大小若為0，相當(dāng)于內(nèi)存中沒有為該類所創(chuàng)對象分配空間，等價于對象不存在，所以是不可能的。

接下來都使用棧和日期類來理解類和對象中的知識。

5. this 指針

class Date {
public:
	void Init(int year, int month, int day) {
		//year = year;//Err
		//1.
        _year = year;
        //2.
        Date::month = month;
        //3.
		this->day = day;
	}
private:
	int _year;
	int month;
	int day;
};

如果成員變量和形參重名的話，在Init函數(shù)中賦值就會優(yōu)先使用形參導(dǎo)致成員變量沒有被初始化，這種問題有三種解決方案：

1. 在成員變量名前加_，以區(qū)分成員和形參。
2. 使用域訪問修飾符::，指定前面的變量是成員變量。
3. 使用 this 指針。

5.1 this 指針的定義

d1._year;的意義是告訴編譯器到d1這個對象中查找變量_year的地址。但函數(shù)并不存放在類對象中，那d1.Print();的意義是什么？

如圖所示，d1,d2兩個對象調(diào)用存儲在公共代碼區(qū)的Print函數(shù)，函數(shù)體中并沒有區(qū)分不同對象，如何做到區(qū)分不同對象的調(diào)用呢？

C++中通過引入 this 指針解決該問題，C++編譯器給每個非靜態(tài)的成員函數(shù)增加了一個隱藏的參數(shù)叫 this 指針。this 指針指向當(dāng)前調(diào)用對象，函數(shù)體中所有對成員變量的操作都通過該指針訪問，但這些操作由編譯器自動完成，不需要主動傳遞。

如圖所示，在傳參時隱藏地傳入了對象的指針，形參列表中也對應(yīng)隱藏增加了對象指針，函數(shù)體中的成員變量前也隱藏了 this 指針。

5.2 this 指針的特性

this是C++的一個關(guān)鍵字，代表當(dāng)前對象的指針。this 指針是成員函數(shù)第一個隱含的指針形參，一般由寄存器傳遞不需要主動傳參。

1. 調(diào)用成員函數(shù)時，不可以顯式傳入 this 指針，成員函數(shù)參數(shù)列表也不可顯示聲明 this 指針。
2. 但成員函數(shù)中可以顯式使用 this 指針。
3. this 的類型為classType* const，加const是為了防止 this 指針被改變。
4. this 指針本質(zhì)上是成員函數(shù)的形參，函數(shù)被調(diào)用時對象地址傳入該指針，所以 this 指針是形參存儲在函數(shù)棧幀中，對象中不存儲this指針。

Example 1和2哪個會出現(xiàn)問題，出什么問題？

class A {
public:
	void Printa() {
		cout <<  _a << endl;
	}
	void Show() {
		cout << "Show()" << endl;
	}
private:
	int _a;
};
int main()
{
	A* a = nullptr;
	//1.
	a->Show();
	//2.
	a->Printa();
	return 0;
}

函數(shù)沒有存儲在對象中，所以調(diào)用函數(shù)并不會訪問空指針a，僅是空指針作參數(shù)傳入成員函數(shù)而已。二者沒有程序語法錯誤，所以編譯一定通過。

調(diào)用Show()函數(shù)沒有訪問對象中的內(nèi)容，不存在訪問空指針的問題。調(diào)用Print()函數(shù)需到a指針?biāo)笇ο笾性L問成員_a，所以訪問空指針程序崩潰。

類和對象<中>

默認(rèn)成員函數(shù)

一個對象都要要對其進(jìn)行初始化，釋放空間，拷貝復(fù)制等等操作，像棧結(jié)構(gòu)不初始化直接壓棧就會報錯。由于這些操作經(jīng)常使用或是必不可少，在設(shè)計之初就被放到類中作為默認(rèn)生成的成員函數(shù)使用，解決了C語言的一些不足之處。

C++在設(shè)計類的默認(rèn)成員函數(shù)的機(jī)制較為復(fù)雜，一個類有6個默認(rèn)的成員函數(shù)，分別為構(gòu)造函數(shù)、析構(gòu)函數(shù)、拷貝構(gòu)造函數(shù)、賦值運算符重載、T* operator&()和const T* operator&()const。他們都是特殊的成員函數(shù)，這些特殊函數(shù)不能被當(dāng)作常規(guī)函數(shù)調(diào)用。

默認(rèn)的意思是我們不寫編譯器也會自動生成一份在類里，如果我們寫了編譯器就不生成了。自動生成默認(rèn)函數(shù)有的時候功能不夠全面，還是得自己寫。

1. 構(gòu)造函數(shù)

1.2 構(gòu)造函數(shù)的定義

構(gòu)造函數(shù)和析構(gòu)函數(shù)分別是完成初始化和清理資源的工作。構(gòu)造函數(shù)就相當(dāng)于數(shù)據(jù)結(jié)構(gòu)時期我們寫的初始化Init函數(shù)。

構(gòu)造函數(shù)是一個特殊的函數(shù)，名字與類名相同，創(chuàng)建類對象時被編譯器自動調(diào)用用于初始化每個成員變量，并且在對象的生命周期中只調(diào)用一次。

2.2 構(gòu)造函數(shù)的特性

構(gòu)造函數(shù)雖然叫構(gòu)造函數(shù)，但構(gòu)造函數(shù)的工作并不是開辟空間創(chuàng)建對象，而初始化對象中的成員變量。

• 函數(shù)名和類名相同，且無返回類型。
• 對象實例化時由編譯器自動調(diào)用其對應(yīng)的構(gòu)造函數(shù)。
• 構(gòu)造函數(shù)支持函數(shù)重載。

//調(diào)用無參的構(gòu)造函數(shù)
Date d1;
Date d2(); //Err - 函數(shù)聲明
//調(diào)用帶參的構(gòu)造函數(shù)
Date d2(2020,1,18);

注意，調(diào)用構(gòu)造函數(shù)只能在對象實例化的時候，且調(diào)用無參的構(gòu)造函數(shù)不能帶括號，否則會當(dāng)成函數(shù)聲明。

• 若類中沒有顯式定義構(gòu)造函數(shù)，程序默認(rèn)創(chuàng)建的構(gòu)造函數(shù)是無參無返回類型的。一旦顯式定義了編譯器則不會生成。
• 無參的構(gòu)造函數(shù)、全缺省的構(gòu)造函數(shù)和默認(rèn)生成的構(gòu)造函數(shù)都可以是默認(rèn)構(gòu)造函數(shù)（不傳參也可以調(diào)用的構(gòu)造函數(shù)），且防止沖突默認(rèn)構(gòu)造函數(shù)只能有一個。

默認(rèn)構(gòu)造函數(shù)初始化規(guī)則

從上圖可以看出，默認(rèn)生成的構(gòu)造函數(shù)對內(nèi)置類型的成員變量不進(jìn)行有效初始化。其實，編譯器默認(rèn)生成的構(gòu)造函數(shù)僅對自定義類型進(jìn)行初始化，初始化的方式是在創(chuàng)建該自定義類型的成員變量后調(diào)用它的構(gòu)造函數(shù)。倘若該自定義類型的類也是默認(rèn)生成的構(gòu)造函數(shù)，那結(jié)果自然也沒有被有效初始化。

默認(rèn)生成的構(gòu)造函數(shù)對內(nèi)置類型的成員變量不作處理，對自定義類型成員會調(diào)用它們的構(gòu)造函數(shù)來初始化自定義類型成員變量。

一個類中最好要一個默認(rèn)構(gòu)造函數(shù)，因為當(dāng)該類對象被當(dāng)作其他類的成員時，系統(tǒng)只會調(diào)用默認(rèn)的構(gòu)造函數(shù)。

目前還只是了解掌握基本的用法，對構(gòu)造函數(shù)在之后還會再談。

2. 析構(gòu)函數(shù)

析構(gòu)函數(shù)同樣是個特殊的函數(shù)，負(fù)責(zé)清理和銷毀一些類中的資源。

2.1 析構(gòu)函數(shù)的定義

與構(gòu)造函數(shù)的功能相反，析構(gòu)函數(shù)負(fù)責(zé)銷毀和清理資源。但析構(gòu)函數(shù)不是完成對象的銷毀，對象是main函數(shù)棧幀中的局部變量，所以是隨 main 函數(shù)棧幀創(chuàng)建和銷毀的。析構(gòu)函數(shù)會在對象銷毀時自動調(diào)用，主要清理的是對象中創(chuàng)建的一些成員變量比如動態(tài)開辟的空間等。

2.2 析構(gòu)函數(shù)的特性

• 析構(gòu)函數(shù)的名字是~加類名，同樣是無參無返回類型，故不支持重載。
• 一個類中有且僅有一個析構(gòu)函數(shù)，同樣若未顯式定義，編譯器自動生成默認(rèn)的析構(gòu)函數(shù)。
• 對象生命周期結(jié)束時，系統(tǒng)自動調(diào)用析構(gòu)函數(shù)完成清理工作。
• 多個對象調(diào)用析構(gòu)函數(shù)的順序和創(chuàng)建對象的順序是相反的，因為哪個對象先壓棧哪個對象就后銷毀。

調(diào)用對象后自動調(diào)用析構(gòu)函數(shù)，這樣的機(jī)制可以避免忘記釋放空間以免內(nèi)存泄漏的問題。不一定所有類都需要析構(gòu)函數(shù)，但對于有些類如棧就很方便。

默認(rèn)析構(gòu)函數(shù)清理規(guī)則

和默認(rèn)生成的構(gòu)造函數(shù)類似，默認(rèn)生成的析構(gòu)函數(shù)同樣對內(nèi)置類型的成員變量不作處理，只在對象銷毀時對自定義類型的成員會調(diào)用它們的析構(gòu)函數(shù)來清理該自定義類型的成員變量。

倘若該自定義類型成員同樣只有系統(tǒng)默認(rèn)生成的的析構(gòu)函數(shù)，那么結(jié)果就相當(dāng)于該自定義類型成員也沒有被銷毀。

不釋放內(nèi)置類型的成員也是有一定道理的，防止釋放一些文件指針等等可能導(dǎo)致程序崩潰。

3. 拷貝構(gòu)函數(shù)

除了初始化和銷毀工作以外，最常見的就是將一個對象賦值、傳參等就必須要拷貝對象。而類這種復(fù)雜類型直接賦值是不起作用的，拷貝對象的操作要由拷貝構(gòu)造函數(shù)實現(xiàn)，每次復(fù)制對象都要調(diào)用拷貝構(gòu)造函數(shù)。

3.1 拷貝構(gòu)造函數(shù)的定義

根據(jù)需求我們也可以猜測出C++中的拷貝構(gòu)造函數(shù)的設(shè)計。

拷貝構(gòu)造函數(shù)也是特殊的成員函數(shù)，負(fù)責(zé)對象的拷貝賦值工作，這個操作只能發(fā)生在對象實例化的時候，拷貝構(gòu)造的本質(zhì)就是用同類型的對象初始化新對象，所以也算是一種不同形式的構(gòu)造函數(shù)滿足重載的要求，也可叫復(fù)制構(gòu)造函數(shù)。

拷貝構(gòu)造函數(shù)僅有一個參數(shù)，就是同類型的對象的引用，在用同類型的對象初始化新對象時由編譯器自動調(diào)用?？截悩?gòu)造函數(shù)也是構(gòu)造函數(shù)，所以拷貝也是構(gòu)造的一個重載。

3.2 拷貝構(gòu)造函數(shù)的特性

• 拷貝構(gòu)造函數(shù)是構(gòu)造函數(shù)的一個重載形式。
• 拷貝構(gòu)造函數(shù)只有一個參數(shù)，且必須是同類型的對象的引用，否則會引發(fā)無窮遞歸。

因為傳值調(diào)用就要復(fù)制一份對象的臨時拷貝，而要想拷貝對象就必須要調(diào)用拷貝構(gòu)造函數(shù)，而調(diào)用拷貝構(gòu)造函數(shù)又要傳值調(diào)用，這樣就會在調(diào)用參數(shù)列表中“邏輯死循環(huán)”出不來了。

設(shè)計拷貝構(gòu)造函數(shù)時就已經(jīng)修改了系統(tǒng)默認(rèn)生成的拷貝構(gòu)造函數(shù)，所以在此過程不可以再發(fā)生拷貝操作。而傳引用不會涉及到拷貝操作所以沒問題。

另外，有趣的是設(shè)計者規(guī)定拷貝構(gòu)造函數(shù)的參數(shù)必須是同類型的引用，如果設(shè)計成指針，系統(tǒng)就當(dāng)作沒有顯式定義拷貝構(gòu)造函數(shù)了。

一般拷貝構(gòu)造另一個對象時，都不希望原對象發(fā)生改變，所以形參引用用const修飾。

只顯式定義拷貝構(gòu)造函數(shù)，系統(tǒng)不會生成默認(rèn)的構(gòu)造函數(shù)，只定義構(gòu)造函數(shù)，系統(tǒng)會默認(rèn)生成拷貝構(gòu)造。

默認(rèn)拷貝構(gòu)造拷貝規(guī)則

若未顯式定義拷貝構(gòu)造，和構(gòu)造函數(shù)類似，默認(rèn)生成的拷貝構(gòu)造函數(shù)對成員的拷貝分兩種：

• 對于內(nèi)置類型的成員變量，默認(rèn)生成的拷貝構(gòu)造是把該成員的存儲內(nèi)容按字節(jié)序的順序逐字節(jié)拷貝至新對象中的。這樣的拷貝被稱為淺拷貝或稱值拷貝。類似與memcopy函數(shù)。
• 對于自定義類型的成員，默認(rèn)生成的拷貝構(gòu)造函數(shù)是調(diào)用該自定義類型成員的拷貝構(gòu)造函數(shù)進(jìn)行拷貝的。

默認(rèn)生成的拷貝函數(shù)也不是萬能的，比如棧這個結(jié)構(gòu)。用st1初始化st2時，會導(dǎo)致二者的成員_a指向相同的一塊空間。

4. 運算符重載

運算符重載是C++的一大利器，使得對象也可以用加減乘除等各種運算符來進(jìn)行相加相減比較大小等有意義的運算。默認(rèn)情況下C++不支持自定義類型像內(nèi)置類型變量一樣使用運算符的，這里的規(guī)則需要開發(fā)者通過運算符重載函數(shù)來定義。

4.1 運算符重載的定義

運算符重載增強(qiáng)了代碼的可讀性也更方便，但為此我們必須要為類對象編寫運算符重載函數(shù)以實現(xiàn)這樣操作。運算符重載是具有特殊函數(shù)名的函數(shù)，也具有返回類型、函數(shù)名和參數(shù)列表。重載函數(shù)實現(xiàn)后由編譯器自動識別和調(diào)用。

1. 函數(shù)名是關(guān)鍵字operator加需要重載的運算符符號，如operator+，operator=等。
2. 返回類型和參數(shù)都要根據(jù)運算符的規(guī)則和含義的實際情況來定。

bool operator>(const Date& d1, const Date& d2) {
	if (d1._year > d2._year) {
		return true;
	}
	else if (d1._year == d2._year && d1._month > d2._month) {
		return true;
	}
	else if (d1._year == d2._year && d1._month == d2._month && d1._day > d2._day) {
		return true;
	}
	return false;
}
d1 > d2;
operator>(d1, d2);

兩個日期類進(jìn)行比較大小，傳參采用對象的常引用形式，避免調(diào)用拷貝構(gòu)造函數(shù)和改變實參，返回類型為布爾值，同樣都是符合實際的。編譯器把operator>(d1,d2)轉(zhuǎn)換成d1>d2，大大提高了代碼的可讀性。

4.2 運算符重載的特性

• 只能重載已有的運算符，不能通過連接其他符號來定義新的運算，如operator@。
• 重載操作符函數(shù)只能作用于自定義類型對象，且最多有兩個參數(shù)，自定義類型最好采用常引用傳參。
• 重載內(nèi)置類型的操作符，建議不改變該操作符本身含義。
• 共有5個運算符不可被重載，分別是：.*，域訪問操作符::，sizeof，三目運算符?:，結(jié)構(gòu)成員訪問符.。

運算符重載不像構(gòu)造函數(shù)是固定在類中的特殊的成員函數(shù)，運算符重載適用于所有自定義類型對象，并不單獨局限于某個類。但由于類中的成員變量是私有的，運算符重載想使其作用于某個類時，解決方法有三：

1. 修改成員變量的訪問權(quán)限變成公有，但破壞了類的封裝性，是最不可取的。使用友元函數(shù)，但性質(zhì)與修改訪問權(quán)限類似，同樣不可取的。
2. 使用Getter Setter方法提供成員變量的接口，保留封裝性但較為麻煩。
3. 將運算符重載函數(shù)放到類中變成成員函數(shù)，但需要注意修改一些細(xì)節(jié)。作為類成員的重載函數(shù)，形參列表默認(rèn)隱藏 this 指針，所以必須去掉一個引用參數(shù)。

class Date {
public:
	Date(int year = 0, int month = 1, int day = 1);
	bool operator>(const Date& d);
private:
	int _year;
	int _month;
	int _day;
};
//bool Date::operator>(Date* this, const Date& d) {...}
bool Date::operator>(const Date& d) {
	// ...
}
d1 > d2;
d1.operator>(d2); //成員函數(shù)只能這樣調(diào)用

4.3 賦值運算符重載

賦值運算符重載實現(xiàn)的是兩個自定義類型的對象的賦值，和拷貝構(gòu)造函數(shù)不同拷貝構(gòu)造是用一個已存在的對象去初始化一個對象，賦值運算符重載是兩個已存在的對象進(jìn)行賦值操作。和兩個整形數(shù)據(jù)的賦值意義相同，所以定義時也是參考內(nèi)置類型的賦值操作來的。

• 參數(shù)列表 —— 兩個對象進(jìn)行賦值操作，由于放在類中作成員函數(shù)，參數(shù)列表僅顯式定義一個對象的引用。
• 返回類型 —— 賦值表達(dá)式的返回值也是操作數(shù)的值，返回對象的引用即可。

// i = j = k = 1;
Date& Date::operator=(const Date& d) {
	if (this != &d) { //優(yōu)化自己給自己賦值
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	return *this;
}

不傳參對象的引用或者不返回對象的引用都會調(diào)用拷貝構(gòu)造函數(shù)，為使減少拷貝和避免修改原對象，最好使用常引用。

默認(rèn)賦值重載賦值規(guī)則

類中如果沒有顯式的定義賦值重載函數(shù)，編譯器會在類中默認(rèn)生成一個賦值重載函數(shù)的成員函數(shù)。默認(rèn)賦值重載對于內(nèi)置類型的成員采用淺拷貝的方式拷貝，對于自定義類型的成員會調(diào)用它內(nèi)部的賦值重載函數(shù)進(jìn)行賦值。

所以寫不寫賦值重載仍然要視情況而定。

Date d5 = d1;
// 用已存在的對象初始化新對象，則是拷貝構(gòu)造而非賦值重載

掌握以上四種C++中默認(rèn)的函數(shù)，就可以實現(xiàn)完整的日期類了。

5. 日期類的實現(xiàn)

5.1 日期類的定義

class Date {
public:
	Date(int year = 0, int month = 1, int day = 1);
	Date(const Date& d);
	~Date();
    void Print();
	int GetMonthDay();

    bool operator>(const Date& d);
	bool operator<(const Date& d);
	bool operator>=(const Date& d);
	bool operator<=(const Date& d);
	bool operator==(const Date& d);
	bool operator!=(const Date& d);

	Date& operator=(const Date& d);

	Date& operator+=(int day);
	Date operator+(int day);
	Date& operator-=(int day);
	int operator-(const Date& d);
	Date operator-(int day);

	Date& operator++();
	Date operator++(int);
	Date& operator--();
	Date operator--(int);
private:
	int _year;
	int _month;
	int _day;
};

日期類很簡單，一樣的函數(shù)一樣的變量再封裝起來，把之前聯(lián)系的代碼放到一起。接下來就是函數(shù)接口的具體實現(xiàn)細(xì)節(jié)了。

5.2 日期類的接口實現(xiàn)

//構(gòu)造函數(shù)
Date(int year = 0, int month = 1, int day = 1);
//打印
void Print();
//拷貝構(gòu)造
Date(const Date& d);
//析構(gòu)函數(shù)
~Date();
//獲取當(dāng)月天數(shù)
int GetMonthDay();
// >運算符重載
bool operator>(const Date& d);
// >=運算符重載
bool operator>=(const Date& d);
// <運算符重載
bool operator<(const Date& d);
// <=運算符重載
bool operator<=(const Date& d);
// ==運算符重載
bool operator==(const Date& d);
// !=運算符重載
bool operator!=(const Date& d);
// =運算符重載
Date& operator=(const Date& d);
//日期+天數(shù)=日期
Date& operator+=(int day);
//日期+天數(shù)=日期
Date operator+(int day);
//日期-天數(shù)=日期
Date& operator-=(int day);
//日期-日期=天數(shù)  
int operator-(const Date& d);
//日期-天數(shù)=日期
Date operator-(int day);
//前置++
Date& operator++();
//后置++
Date operator++(int);
//前置--
Date& operator--();
//后置--
Date operator--(int);

從上述函數(shù)聲明的列表也可以看出，構(gòu)造函數(shù)、析構(gòu)函數(shù)等都是相對簡單的，實現(xiàn)類的重點同樣也是難點是定義各種運算符的重載。

日期類的構(gòu)造函數(shù)

日期類的構(gòu)造函數(shù)之前實現(xiàn)過，但仍需注意一些細(xì)節(jié)，比如過濾掉一些不合法的日期。要想實現(xiàn)這個功能就要定好每年每月的最大合法天數(shù)，可以將其存儲在數(shù)組MonthDayArray，并封裝在函數(shù)GetMonthDay中以便在判斷的時候調(diào)用。

//獲取合法天數(shù)的最大值
int Date::GetMonthDay() {
	static int MonthDayArray[13] = { 0, 31 ,28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	int day = MonthDayArray[_month];
	//判斷閏年
	if (_month == 2 && ((_year % 4 == 0 && _year % 100 != 0) || (_year % 400 == 0))) {
		day += 1;
	}
	return day;
}
//構(gòu)造函數(shù)
Date::Date(int year, int month, int day) {
	_year = year;
	_month = month;
	_day = day;
	//判斷日期是否合法
	if (month > 12 || day > GetMonthDay()) {
		cout << "請檢查日期是否合法：";
		Print();
	}
}

數(shù)組MonthDayArray的定義也有講究，定義13個數(shù)組元素，第一個元素就放0，這樣讓數(shù)組下標(biāo)和月份對應(yīng)起來，使用更加方便。確定每月的天數(shù)還要看年份是否是閏年，所以還要判斷是否是閏年，因為閏年的二月都要多一天。這些封裝在函數(shù)GetMonthDay中，調(diào)用時返回當(dāng)月具體天數(shù)，放在構(gòu)造函數(shù)中判斷是否日期是否合法。

由于兩個函數(shù)都是定義在類中的，默認(rèn)將類對象的指針作函數(shù)參數(shù)，調(diào)用時更加方便。

析構(gòu)函數(shù)、打印函數(shù)和拷貝構(gòu)造函數(shù)都很簡單和之前一樣，這里就不寫了。接下來就是實現(xiàn)的重點運算符重載。

比較運算符的重載

//運算符重載 >
bool Date::operator>(const Date& d) {
	if (_year > d._year) {
		return true;
	}
	else if (_year == d._year && _month > d._month) {
		return true;
	}
	else if (_year == d._year && _month == d._month && _day > d._day) {
		return true;
	}
	return false;
}
//運算符重載 >=
bool Date::operator>=(const Date & d) {
	return (*this > d) || (*this == d);
}
//運算符重載 <
bool Date::operator<(const Date& d) {
	return !(*this >= d);
}
//運算符重載 <=
bool Date::operator<=(const Date& d) {
	return !(*this > d);
}
//運算符重載 ==
bool Date::operator==(const Date& d) {
	return (_year == d._year) && (_month == d._month) && (_day == d._day);
}
//運算符重載 !=
bool Date::operator!=(const Date& d) {
	return !(*this == d);
}

比較運算符的重載不難實現(xiàn)，注意代碼的邏輯即可。主要實現(xiàn)>和==的重載，其他的都調(diào)用這兩個函數(shù)就行。這樣的實現(xiàn)方法基本適用所有的類。

加法運算符的重載

加法實現(xiàn)的意義在于實現(xiàn)日期+天數(shù)=日期的運算，可以現(xiàn)在稿紙上演算一下探尋一下規(guī)律。

可以看出加法的規(guī)律是，先將天數(shù)加到天數(shù)位上，然后判斷天數(shù)是否合法。

1. 如果不合法則要減去當(dāng)月的最大合法天數(shù)值，相當(dāng)于進(jìn)到下一月，即先減值再進(jìn)位。
2. 若天數(shù)合法，則進(jìn)位運算結(jié)束。
3. 在天數(shù)進(jìn)位的同時，月數(shù)如果等于13則賦值為1，再年份加1，可將剩余天數(shù)同步到明年。

先減值再進(jìn)位的原因是，減值所減的是當(dāng)月的最大合法天數(shù)，若先進(jìn)位的話，修改了月份則會減成下個月的天數(shù)。

//運算符重載 +=
//日期 + 天數(shù) = 日期 
Date& Date::operator+=(int day) {
	_day += day;
	//檢查天數(shù)是否合法
	while (_day > GetMonthDay()) {
		_day -= GetMonthDay();//天數(shù)減合法最大值 --- 先減值，再進(jìn)位
		_month++;//月份進(jìn)位
		//檢查月數(shù)是否合法
        if (_month == 13) { 
			_month = 1;
			_year += 1;//年份進(jìn)位
		}
	}
	return *this;
}

這樣的實現(xiàn)方法會改變對象的值，不如直接將其實現(xiàn)為+=，并返回對象的引用還可以避免調(diào)用拷貝構(gòu)造。

實現(xiàn)+重載再去復(fù)用+=即可。

//運算符重載 +
Date Date::operator+(int day) {//臨時變量會銷毀，不可傳引用
	Date ret(*this);
	ret += day; // ret.operator+=(day);
	return ret;
}

創(chuàng)建臨時變量并用*this初始化，再使用臨時變量進(jìn)行+=運算，返回臨時變量即可。注意臨時變量隨棧幀銷毀，不可返回它的引用。

減法運算符的重載

//運算符重載 -=
//日期 - 天數(shù) = 日期
Date& Date::operator-=(int day) {
    //防止天數(shù)是負(fù)數(shù)
	if (_day < 0) {
		return *this += -day;
	}
	_day -= day;
	//檢查天數(shù)是否合法
	while (_day <= 0) {
		_month--;//月份借位
		//檢查月份是否合法
		if (_month == 0) {
			_month = 12;
			_year--;//年份借位
		}
		_day += GetMonthDay();//天數(shù)加上合法最大值 --- 先借位，再加值
	}
	return *this;
}

實現(xiàn)減法邏輯和加法類似，先將天數(shù)減到天數(shù)位上，再檢查天數(shù)是否合法：

1. 如果天數(shù)不合法，向月份借位，再加上上月的最大合法天數(shù)，即先借位再加值。并檢查月份是否合法，月份若為0則置為12年份再借位。
2. 如果天數(shù)合法，則停止借位。

先借位再加值是因為加值相當(dāng)于去掉上個月的過的天數(shù)，所以應(yīng)加上的是上月的天數(shù)。

值得注意的是，修正月數(shù)的操作必須放在加值的前面，因為當(dāng)月數(shù)借位到0時，必須要修正才能正常加值。

//運算符重載 -
//日期 - 天數(shù) = 日期
Date Date::operator-(int day) {
	Date ret(*this);
	ret -= day;
	return ret;
}
//日期 - 日期 = 天數(shù)  
int Date::operator-(const Date& d) {
	int flag = 1;
	Date max = *this;
	Date min = d;
	if (max < min) {
		max = d;
		min = *this;
		flag = -1;
	}
	int gap = 0;
	while ((min + gap) != max) {
		gap++;
	}
	return gap * flag;
}

日期-日期=天數(shù)的計算可以稍微轉(zhuǎn)化一下變成日期+天數(shù)=日期，讓小的日期加上一個逐次增加的值所得結(jié)果和大的日期相等，那么這個值就是二者所差的天數(shù)。

加的時候，日期不合法是因為天數(shù)已經(jīng)超出了當(dāng)月的最大合法天數(shù)，既然超出了，就將多余的部分留下，把當(dāng)月最大合法天數(shù)減去以增加月數(shù)。減的時候同理，日期不合法是因為天數(shù)已經(jīng)低于了0，回到了上一個月，那就補(bǔ)全上一個月的最大合法數(shù)值用此去加上這個負(fù)數(shù)，這個負(fù)數(shù)就相當(dāng)于此月沒有過完的剩余的天數(shù)。

自增自減的重載

C++為區(qū)分前置和后置，規(guī)定后置自增自減的重載函數(shù)參數(shù)要顯式傳一個int參數(shù)占位，可以和前置構(gòu)成重載。

//前置++
Date& Date::operator++() {
	return *this += 1;
}
//后置++
Date Date::operator++(int) {
	return (*this += 1) - 1;
}
//前置--
Date& Date::operator--() {
	return *this -= 1;
}
//后置--
Date Date::operator--(int) {
	return (*this -= 1) + 1;
}
// 實現(xiàn)方式2
Date ret = *this;
*this + 1;
return ret;

實現(xiàn)對象的前置后置的自增和自減，要滿足前置先運算再使用和后置先使用再運算的特性。也用上面實現(xiàn)好的重載復(fù)用即可?；蛘咭部梢灾苯永门R時變量保存*this，改變*this之后返回臨時變量即可。

++d2;
d2.operator();
d1++;
d1.operator(0);

可以看出，對于類對象來說，前置++比后置++快不少，只調(diào)用了一次析構(gòu)函數(shù)，而后置++ 調(diào)用了兩次拷貝構(gòu)造和三次析構(gòu)。

6. const 類

被const修飾的類即為 const 類，const 類調(diào)用成員函數(shù)時出錯，因為參數(shù)this指針從const Date*到Date*涉及權(quán)限放大的問題。如圖所示：

6.1 const 類的成員函數(shù)

想要避免這樣的問題，就必須修改成員函數(shù)的形參this，但 this 指針不能被顯式作參數(shù)自然不可被修改。為解決這樣的問題，C++規(guī)定在函數(shù)聲明后面加上 const ，就相當(dāng)于給形參 this 指針添加 const 修飾。

//運算符重載 !=
//聲明
bool Date::operator!=(const Date& d) const;
//定義
bool Date::operator!=(const Date& d) const {
	return !(*this == d);
}

像上述代碼這樣，由 const 修飾的類成員函數(shù)稱之為 const 成員函數(shù)，const 修飾類成員函數(shù)，實際修飾函數(shù)的隱含形參 this 指針，這樣該函數(shù)就不可修改對象的成員變量。

6.2 取地址操作符重載

還有兩個類的默認(rèn)成員函數(shù)，取地址操作符重載和 const 取地址操作符重載，這兩個默認(rèn)成員函數(shù)一般不用定義，編譯器默認(rèn)生成的就夠用了。

Date* operator&() {
    return this;
    //return NULL; //不允許獲取對象的地址
}
const Date* operator&() const {
    return this;
}

當(dāng)不允許獲取對象的地址時，就可以將取地址重載成空即可。

總結(jié)

到此這篇關(guān)于C++初階教程之類和對象的文章就介紹到這了,更多相關(guān)C++類和對象內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！