C++深入講解類與對象之OOP面向對象編程與封裝

Posted on by

面向過程編程也叫結構化編程。雖然結構化編程的理念提高瞭程序的清晰度，可靠性，並且方便維護。但它再編寫大型的程序時，仍然面臨這巨大的挑戰，OOP(面向對象編程)提供瞭一種新的方法。與強調算法的過程性編程不同的是，OOP強調的是數據。–引自《C++ Primer Plus(第六版)》

1.面向對象編程

C++ 是 基於面向對象 的， 關註 的是 對象 ，將一件事情拆分成不同的對象，靠對象之間的交互完成。

在C++中，類是一種規范，它描述瞭這種新型數據格式，對象是根據這種規范構造的特定數據結構。這裡有小夥伴會問，類是什麼？這個問題會在（3.類的引入） 中重點介紹。

2.面向過程性編程和面向對象編程

通過下面這個例子，可以更加清晰的揭示OOP的觀點和過程性編程的差別。

此舉例改變自《C++ Primer Plus(第六版)》:

曼聯足球俱樂部的一名新成員被要求記錄球隊的統計數據。很自然他會借助計算機來完成這項任務。

如果這個新成員是過程性程序員，可能會這樣考慮：

我要輸入每名運動員的姓名，進球數，助攻數，登場數等其他重要的基本統計數據。之所以使用計算機，是為瞭簡化統計工作，因此讓他來計算某些數據。另外，我還希望程序能夠顯示這些結果。應該如何組織呢？我讓main()調用一個函數來獲取輸入，調用另外一個函數來進行計算，然後調用第三個函數來顯示結果。那麼，獲得下一場比賽的數據後，又改怎麼做呢？當然不想從頭開始，可以添加一個函數來更新統計數據。可能需要在main函數中添加一個菜單，選擇是輸入，計算，更新還是顯示數據等。則如何表示這些數據呢。可以使用一個字符串來存儲選手的姓名，用另外一個數組來存儲每位球員的進球數，再用一個數組存儲助攻數等等。這種方法太不靈活瞭。因此可以設計一個結構體來存儲每位球員的所有信息，然後用這種結構組成的數組來表示整個球隊。

總之，采用過程性編程時，首先要考慮遵守的步驟，然後考慮如何表示這些數據。

如果換成一個OOP程序員，又將如何考慮呢？

首先要考慮數據——不僅要考慮如何表示數據，還要考慮如何使用數據：

OOP程序員會想，我要跟蹤的是什麼？當然是球員。因此要有一個對象表示整個球員的各個方面（不僅僅是進球數或助攻數）。因此這將是基本數據單元——一個表示球員的姓名和統計數據的對象。我需要一些處理該對象的方法。首先需要一種將基本信息加入到該單元中的方法；其次，計算機應計算一些東西，如進球率。因此要添加一些執行計算的方法。程序應自動完成這些計算，而無需用戶的幹擾。另外，還需要一些更新和顯示信息的方法。所以，用戶與數據交互的方式有三種：初始化，更新和報告——這就是用戶接口。

總之，采用OOP方法時，首先從用戶的角度考慮對象——描述對象所需的數據以及描述用戶與數據交互所需的操作。完成對接口的描述之後，需要確定如何實現接口和數據存儲。最後，使用尋得設計方案創建出程序。

3.類的引入

在過程化編程中我們用結構體來描述一個復雜對象（這裡用C語言舉例）。在C語言中，結構體中隻能定義變量。結構體關鍵字是struct。在C++中，結構體內不僅可以定義變量，還可以定義函數

struct Student
{
	void SetStudentInfo(const char* name, const char* gender, int age)
	{
		strcpy(_name, name);
		strcpy(_gender, gender);
		_age = age;
	}
	void PrintStudentInfo()
	{
		cout << _name << " " << _gender << " " << _age << endl;
	}
	char _name[20];
	char _gender[3];
	int _age;
};
int main()
{
 Student s;
 s.SetStudentInfo("Peter", "男", 18);
 return 0; 
}

上面結構體的定義， 在 C++ 中更喜歡用 class 來代替

4.類的定義

class className
{
    // 類體：由成員函數和成員變量組成
}; // 一定要註意後面的分號

class為定義類的關鍵字，ClassName為類的名字，{}中為類的主體，註意類定義結束時後面分號。

類中的元素稱為類的成員：類中的數據稱為類的屬性或者成員變量; 類中的函數稱為類的方法或者成員函數。

4.1類的兩種定義方式

4.1.1聲明和定義全部放在類體中

需要註意：成員函數如果在類中定義 ，編譯器可能會將其當成 內聯函數 處理。

class Student
{
public:
	void SetStudentInfo(const char* name, const char* gender, int age)
	{
		strcpy(_name, name);
		strcpy(_gender, gender);
		_age = age;
	}
	void PrintStudentInfo()
	{
		cout << _name << " " << _gender << " " << _age << endl;
	}
public:
	char _name[20];
	char _gender[3];
	int _age;
};

4.2.2.聲明和定義不放在類體中

聲明放在.h文件中，類的定義放在.cpp文件中

//student.h
//學生
class Student 
{
public:
	void SetStudentInfo(const char* name, const char* gender, int age);
	void PrintStudentInfo();
public:
	char _name[20];
	char _gender[3];
	int _age;
};
//test.cpp
#include "student.h"
void Student::SetStudentInfo(const char* name, const char* gender, int age)
{
	strcpy(_name, name);
	strcpy(_gender, gender);
	_age = age;
}
void Student::PrintStudentInfo()
{
	cout << _name << " " << _gender << " " << _age << endl;
}

一般情況下，更期望采用第二種方式。

5.類的訪問限定符及封裝

5.1 訪問限定符

在剛剛的代碼中，細心的小夥伴可以發現在類中出現瞭public這個詞，那這到底有什麼用呢？這就是我們現在要說明的訪問限定符。在C++中，除瞭public(公有)外，還有private(私有)，protected(保護)限定符。

那麼為什麼要引入訪問限定符呢？

C++實現封裝的方式：用類將對象的屬性與方法結合在一塊，讓對象更加完善，通過訪問權限選擇性的將其接口提供給外部的用戶使用。

那麼他們都有什麼含義呢？

【訪問限定符說明】

1. public修飾的成員在類外可以直接被訪問

2. protected和private修飾的成員在類外不能直接被訪問(此處protected和private是類似的)

3. 訪問權限作用域從該訪問限定符出現的位置開始直到下一個訪問限定符出現時為止

4. class的默認訪問權限為private，struct為public(因為struct要兼容C)

註意：

1.訪問限定符隻在編譯時有用，當數據映射到內存後，沒有任何訪問限定符上的區別。

2.C++需要兼容C語言，所以C++中struct可以當成結構體去使用。另外C++中struct還可以用來定義類。和class是定義類是一樣的，區別是struct的成員默認訪問方式是public，class是的成員默認訪問方式是private。

5.2封裝

什麼是封裝?

封裝：將數據和操作數據的方法進行有機結合，隱藏對象的屬性和實現細節，僅對外公開接口來和對象進行交互。封裝的本質是一種管理。 我們使用類數據和方法都封裝到一下。 不想給別人看到的，我們使用 protected/private 把成員 封裝 起來。 開放 一些共有的成員函數對成員合理的訪 問。所以封裝本質是一種管理。

在C語言中，大多數情況中調用者和定義結構者不是同一個人，就可能會存在調用者測出bug的可能。

//C語言中數據和方法是分離的
struct Stack
{
	int* _a;
	int _top;
	int _capacity;
};
void StackInit(struct Stack* ps)
{
	assert(ps);
	ps->_a = NULL;
	ps->_capacity = 0;
	ps->_top = 0;
}
void StackPush(struct Stack* ps, int x)
{
}
struct Stack StackTop(struct Stack* ps)
{
}
int main()
{
	struct Stack st;
	StackInit(&st);
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	printf("%d\n", StackTop(&st));
	printf("%d\n", st._a[st._top]);     //可能就存在誤用
	printf("%d\n", st._a[st._top - 1]); //可能就存在誤用
}

這是我們在數據結構階段用C語言實現的一個棧，在主函數中，我們想要訪問棧頂的元素。在常規情況下，我們調用StackTop函數即可訪問到棧頂元素。但是我們也可以使用訪問數組下標的方式拿到棧頂元素，此時如果調用者不清楚使用者的定義方式，就有可能存在誤用。例如：這段代碼我們定義_top是棧頂元素的下一個元素的下標，因此棧頂元素的下標應該是_top-1,而調用者如果誤以為top就是棧頂元素的下標，即有可能存在誤用。因此這裡太過自由。

為瞭解決這一問題，在C++中，結構體不僅可以定義變量，還可以定義函數。我們如果把函數定義在類中，我們把成員變量封裝在類中，外界函數無法調用。因此如果此時我們想調用棧頂元素，我們隻能調用Top函數的接口。這就避免瞭上述問題的發生。

class Stack
{
private:
	void Checkcapacity()
	{
	}
public:
	void Init()
	{
	}
	void Push(int x)
	{
	}
	void Top()
	{
	}
private:
	int* _a;
	int _top;
	int _capacity;
};

6.類的作用域

類定義瞭一個新的作用域 ，類的所有成員都在類的作用域中 。 在類體外定義成員，需要使用 :: 作用域解析符指明成員屬於哪個類域。 就像在這段代碼中，我們想要在類作用域外定義成員，就要使用::

7.類的實例化

用類類型創建對象的過程，稱為類的實例化

1. 類隻是 一個 模型 一樣的東西，限定瞭類有哪些成員，定義出一個類 並沒有分配實際的內存空間 來存儲它

2. 一個類可以實例化出多個對象， 實例化出的對象 占用實際的物理空間，存儲類成員變量

3. 做個比方。 類實例化出對象就像現實中使用建築設計圖建造出房子，類就像是設計圖 ，隻設計出需要什麼東西，但是並沒有實體的建築存在，同樣類也隻是一個設計，實例化出的對象才能實際存儲數據，占用物理空間

我們繼續引用我們剛剛用C++所寫的棧，其中st就是一個實例化對象。

class Stack
{
private:
	void Checkcapacity()
	{
	}
public:
	void Init()
	{
	}
	void Push(int x)
	{
	}
	void Top()
	{
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack st;
	st.Init();
	st.Push(1);
	st.Top();
	return 0;
}

8.類對象模型

如何計算類對象的大小

在C語言中，我們在學習結構體的時候知道，由於結構體中隻定義變量，因此我們是可以計算出結構體的大小的。sizeof計算的是定義類型對象的大小。

那在C++中，由於類中不僅定義變量，還定義函數，那麼類的大小是怎麼計算的呢？

我們發現此類的大小還是12。

因此我們猜測：類對象的存儲方式隻保存成員變量，成員函數存放在公共的代碼段。

那我們思考為什麼采用這種方式呢？

在上述中說到，類就像是一份建築圖紙，而所建造的每一個房子中的name，capacity,top應當是不一樣的。但是所調用的方法Init(),Top()應當是同一個方法。因此沒有必要把函數在對象中存一份。我們也可以通過匯編看看不同的對象是否調用同一個函數。

我們能夠發現st1和st2所調用得Init()函數是同一份。因此如果都把函數存在類中，就會造成浪費。因此我們可以把函數放在一個公共的區域，這個區域叫做代碼段。

結論：一個類的大小，實際就是該類中”成員變量”之和，當然也要進行內存對齊，註意空類的大小，空類比較特殊，編譯器給瞭空類一個字節來唯一標識這個類。註意：最小內存單元是1.操作系統規定都要有地址記錄，就像sizeof(void) = 1。

到此這篇關於C++深入講解類與對象之OOP面向對象編程與封裝的文章就介紹到這瞭,更多相關C++類與對象內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：