1、面向程序和面向物件的區別

??眾所周知，編程語言分為面向物件和面向程序兩大類，那么什么是面向物件，什么又是面向程序呢？？？

??我們以外賣為例對此進行分析：
面向程序：訂外賣、送外賣、取外賣，重點在這三個程序，每個程序什么人去做，怎么做，
面向物件：商家、騎手、客戶，分三個物件，每個物件有目標和任務，該做什么是明確的，
??C語言是面向程序的，關注的是程序，分析出求解問題的步驟，通過函式呼叫逐步解決問題，
??C++是基于面向物件的，關注的是物件，將一件事情拆分成不同的物件，靠物件之間的互動完成，
??我們在類的引入和定義中具體通過代碼來觀察面向程序和面向物件的區別，

2、類的引入和定義

2.1 類的引入

C語言中，結構體中只能定義變數，在C++中，結構體內不僅可以定義變數，也可以定義函式，并且在C語言中，資料和方法是分離的，
從下面可以看出對于面向程序而言，資料和方法是分開的，我們重點關注的是程序->函式！

typedef int STDataType;
//資料
struct MyStack
{
	STDataType* a;
	int size;
	int capacity;
};
//方法
void StackPush(struct Stack* ps, STDataType x);

對于C++而言，延申出一個新的定義–類，類有兩部分組成：成員變數（屬性）和成員函式（行為），并且，一個類中同時存在成員變數和成員函式，

struct Stack
{
	void Init(int initSize = 4)
	{
		a = (STDataType*)malloc(sizeof(STDataType)* initSize);
		size = 0;
		capacity = initSize;
	}
	//需要注意的是：成員變數在這只是宣告，并沒有定義，沒有分配記憶體
	STDataType* a;
	int size;
	int capacity;
};

??值得注意的是，在C++中，不再使用struct，而是使用class定義一個類，當然保留了struct的使用，即在C++中struct代表類，可以同時存在成員變數和成員函式，對于struct和class有什么區別我們在訪問限定符中再給大家詳細介紹，

class Stack //使用class定義一個類
{
	void Init(int initSize = 4)
	{
		a = (STDataType*)malloc(sizeof(STDataType)* initSize);
		size = 0;
		capacity = initSize;
	}
	STDataType* a;
	int size;
	int capacity;
};

2.2類的定義

我們先對類的構成進行分析：
??class為定義類的關鍵字，ClassName為類的名字，{}中為類的主體，注意類定義結束時后面分號，
??類中的元素稱為類的成員：類中的資料稱為類的屬性或者成員變數; 類中的函式稱為類的方法或者成員函式，

class className
{
	// 類體：由成員函式和成員變陣列成
}; // 一定要注意后面的分號

類的定義有兩種方式：
??a：宣告和定義全部放在類體中，需要注意：成員函式如果在類中定義，編譯器可能會將其當成行內函式處理，
??b：宣告放在.h檔案中，類的定義放在.cpp檔案中，
🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋🍋

3、類的訪問限定符及其封裝

3.1訪問限定符

C++實作封裝的方式：用類將物件的屬性與方法結合在一塊，讓物件更加完善，通過訪問權限選擇性的將其介面提供給外部的用戶使用，
??????public（公有）
訪問限定符：protected（保護）
??????private（私有）
【訪問限定符說明】
??1. public修飾的成員在類外可以直接被訪問
??2. protected和private修飾的成員在類外不能直接被訪問(此處protected和private是類似的)
??3. 訪問權限作用域從該訪問限定符出現的位置開始直到下一個訪問限定符出現時為止
??4. class的默認訪問權限為private，struct為public(因為struct要兼容C)
注意：訪問限定符只在編譯時有用，當資料映射到記憶體后，沒有任何訪問限定符上的區別

??所以我們在設計類的程序中，一般將成員變數設計為私有，而對于想給別人訪問的成員函式定義為公有，不想給別人訪問的成員函式定義為私有或保護，至于私有和保護的區別，在后面繼承中才加以區分，

typedef int STDataType;
class Stack
{
public:
	void Init(int initSize = 4);
	void Push(STDataType x);
private:
	STDataType* a;
	int size;
	int capacity;
};

3.2封裝

??面向物件的三大特性：封裝、繼承、多型，
??實際中，大家也要注意，面向物件不止三大特性，比如：抽象、反射(java)，

??封裝實際上是一種管理，好比圖中的遙控器，用戶沒有必要了解它的作業原理，怎么控制頻道的切換，只需直到每個按鈕的作用即可，按鈕就是程式中的成員函式，
??資料和方法都封裝到類中，管理起來，想給你訪問的定義成公有，不想給你訪問的定義成私有或保護，

??那么面向物件的封裝好呢？還是面向程序的不封裝好？ -答案當然是：封裝更好，封裝更嚴格，不封裝更自由

封裝：將資料和操作資料的方法進行有機結合，隱藏物件的屬性和實作細節，僅對外公開介面來和物件進行互動，

4、類的作用域

??因為有類的出現，所以出現了新的作用域—類域，
??類的所有成員都在類的作用域中，在類體外定義成員，需要使用::作用域決議符指明成員屬于哪個類域，

class Person
{
public:
	void PrintPersonInfo();
private:
	char _name[20];
	char _gender[3];
	int _age;
};
// 這里需要指定PrintPersonInfo是屬于Person這個類域
void Person::PrintPersonInfo()
{
	cout << _name << " "_gender << " " << _age << endl;
}

5、類的實體化

??用類的型別創建一個物件的程序就叫做–類的實體化，
????1. 類只是一個模型一樣的東西，限定了類有哪些成員，定義出一個類并沒有分配實際的記憶體空間來存盤它，
????2. 一個類可以實體化出多個物件，實體化出的物件 占用實際的物理空間，存盤類成員變數，
??做個比方，類實體化出物件就像現實中使用建筑設計圖建造出房子，類就像是設計圖，只設計出需要什么東西，但是并沒有物體的建筑存在，同樣類也只是一個設計，實體化出的物件才能實際存盤資料，占用物理空間，

typedef int STDataType;
class Stack
{
public:
	void Init(int initSize = 4);
private:
	STDataType* a;
	int size;
	int capacity;
};
void Stack::Init(int initSize)
{
	a = (STDataType*)malloc(sizeof(STDataType)* initSize);
	size = 0;
	capacity = initSize;
}
int main()
{
	Stack st;
	st.Init();
	//這就是實體化物件
	Stack s1;
	Stack s2;
	return 0;
}

6、 類物件模型

??在這里小編會向大家介紹一下類大小的計算以及類物件的存盤方式，

??類物件的存盤方式無非有兩種：
????a：物件中包含類的各個成員，即成員函式和成員變數都包含
????b：只保存成員變數，成員函式在公共代碼段
??經過分析，每個物件中成員變數是不同的，但是呼叫同一份函式，如果按照方式a存盤，當一個類創建多個物件時，每個物件中都會保存一份代碼，相同代碼保存多次，浪費空間，那么如何解決呢？
??所以最終結果是：只保存成員變數，成員函式存放在公共的代碼段
??我們參照下面的代碼，即可得出以上結論：而對于成員變數的大小計算，則遵頊結構體記憶體對齊規則，相信聰明的你們對這個已經很熟悉，如果還不了解的可以去百度一下，小編搬用的其它博主一篇文章，大家可以點擊結構體記憶體對齊規則進行了解，

class A1 {
public:
	void f1(){}
private:
	int _a;
};
int main()
{
	A1 aa;
	cout << sizeof(A1) << endl;//4

這里還有一種特殊情況，對于沒有成員變數的類，它的大小是多少呢？我們下面來研究，

//a：類中僅有成員函式
class A2 {
public:
	void f2() {}
};
//b:類中什么都沒有 - 空類
class A3
{};
int main()
{
	A2 a2;
	cout << sizeof(a2) << endl;//1

	A3 a3;
	cout << sizeof(a3) << endl;//1
}

??經過結果的輸入，發現結果為1，這是為什么呢？
??在這里，大小是1，并不是代表他們的大小為1，而是給1byte記憶體進行占位，表明這個物件存在過，如果大小為0，對上面的A2類，創建多個物件，a2，aa2，aaa2，那么怎么區分這三個物件呢？唯一的方法就是查看地址，地址不同就說明物件不同，如果大小為2，在記憶體中沒有創建，就不能區分了，所以這里的作用是占位，

7、 this指標

7.1this指標的引出

class Date
{
public:
	void Init(int year, int month, int day)
	{
		//這里面有兩個year，但是引數的訪問遵循就近原則，所以這兩個year都是函式Init引數里的year，所以Date類中的year物件，并沒有賦值
		//這其實是自己賦值給自己了，下面Date類中的year、month、day根本壓根沒作用
		year = year;
		month= month;
		day= day;
	}
private:
	int year; // 年
	int month; // 月
	int day; // 日
};
int main()
{
	Date d1;
	d1.Init(1998, 07, 18);
	return 0;
}

程式經過運行，我們發現Date類中的year、month、day沒有改變，這是為什么呢？我們代碼塊中的注釋已經給了答案，因為就近原則的限制，訪問的兩個year、month、day都是Init形參中的變數，所以沒有進入到Date類中，那么針對這樣的問題，我們應該怎么解決呢？

法一：改變變數的命名風格
經過命名風格改進以后：這樣就沒有沖突了，year就是引數里面的year，_year就是成員變數里的_year

class Date
{
public:
	//這個地方可以手動加this：this->year = year;但是編譯器不會自動加this，因為函式名相同，他也不知道你想訪問那個year，所以最后加域作用符:;或者改命名風格
	void Init(int year, int month, int day)
	{
		_year = year;
		_month= month;
		_day= day;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
	//其他風格：
	//int year_;//_放到變數后面
	//int m_year;//m代表成員變數（member）
	//int mYear;
};
int main()
{
	Date d1;
	d1.Init(1998, 07, 18);
	return 0;
}

法二：使用域作用限定符
加一個“::”，作為指定域的訪問就可以了，但是這樣去寫太麻煩

class Date
{
public:
	void Init(int year, int month, int day)
	{
		Date::year = year;
		Date::month= month;
		Date::day= day;
	}
private:
	int year; // 年
	int month; // 月
	int day; // 日
};
int main()
{
	Date d1;
	d1.Init(1998, 07, 18);
	return 0;
}

法三：this指標
??a：因為這個this是一個隱含引數，所以我們不能越俎代庖在函式的形參以及函式呼叫物件初始化的時候，加上this，比如：void Init(Date* this, int year, int month, int day)、d1.Init(&d1, 1998, 07, 18);，不能自己寫出來
??b：可以在成員函式中使用this指標
??c：this指標是存在堆疊里面的，因為他是一個形參；引數和區域變數都是在堆疊里面，因為this出了這個函式就不用了，所以在堆疊中，不同的編譯器不同，VS是使用ecx暫存器存盤，傳參的

class Date
{
public:
	//這里的Init并不是只有3個引數，而是有4個引數，編譯器遇到他會進行處理，增加一個隱含的引數，這是編譯器編譯時自己加的，
	//void Init(Date* this, int year, int month, int day)//這是固定死的，就叫this
	void Init(int year, int month, int day)
	{
		//經過編譯器處理，加一個this關鍵字以后，類中的函式實際是這樣的
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}
//經過封裝以后，在main函式里是不能隨便更改成員變數的值的，只能初始化或者呼叫類中的函式，函式中可以檢查日期的合法性，保證了成員變數的安全性，
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
int main()
{
	Date d1;
	d1.Init(1998, 07, 18);//d1.Init(&d1, 1998, 07, 18);
	return 0;
}

那么問題又來了？
多個物件進行賦值時，是怎么保證每個物件進行精確進行物件的確定的？

答案是：通過this指標
我們將this列印出來

class Date
{
public:
	void Init(int year, int month, int day)
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
		//列印一下this
		cout << "this：" << this << endl;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
int main()
{
	Date d1;
	cout << "&d1：" << &d1 << endl;
	d1.Init(1998, 07, 18);//d1.Init(&d1, 1998, 07, 18);

	//哪個物件去呼叫成員函式，成員函式中訪問的就是哪個物件中的成員變數，是通過this指標做到的，
	Date d2;
	cout << "&d2：" << &d2 << endl;
	d2.Init(1999, 01, 02);//d1.Init(&d2, 1999, 01, 02);
	return 0;
}

通過圖中，我們可以觀察到，當對物件d1進行賦值時，this此時就是d1，當對d2物件進行操作時，this就是d2，

7.2this指標的特性

?? 1. this指標的型別：型別別* const
?? 2. 只能在“成員函式”的內部使用
?? 3. this指標本質上其實是一個成員函式的形參，是物件呼叫成員函式時，將物件地址作為實參傳遞給this形參，所以物件中不存盤this指標，
?? 4. this指標是成員函式第一個隱含的指標形參，一般情況由編譯器通過ecx暫存器自動傳遞，不需要用戶傳遞
?? 5. this指標是非靜態成員函式的隱含形參，靜態函式沒有this指標，

關于類和物件還有好多內容需要我們進行探討和學習，本篇文章的內容介紹到這里，如果大家還想對類和物件有進一步的了解，麻煩大家多多點贊，小編會繼續更新，