什么是面向物件，什么是面向程序

C語言是面向程序的，關注的是程序，分析出求解問題的步驟，通過函式呼叫逐步解決問題面向程序就是分析出解決問題所需要的步驟，然后用函式把這些步驟一步一步實作，使用的時候一個一個依次呼叫就可以了，
C++是基于面向物件的，關注的是物件，將一件事情拆分成不同的物件，靠物件之間的互動完成面向物件是把構成問題事務分解成各個物件，建立物件的目的不是為了完成一個步驟，而是為了描敘某個事物在整個解決問題的步驟中的行為，
封裝：

1. 把變數（屬性）和函式（操作）合成一個整體，封裝在一個類中
2. 對變數和函式進行訪問控制
   目的：封裝的目的是為了保證變數的安全性，使用者不必在意具體實作細節，而只是通過外部介面即可訪問類的成員

類的引入

C語言中，結構體中只能定義變數，在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;
};
void test01()
{
	Student m1;
	m1.SetStudentInfo("張三", "男", 18);
	m1.PrintStudentInfo();
}

類的引入

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

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

類的權限問題

1. 在類的內部(作用域范圍內)，沒有訪問權限之分，所有成員可以相互訪問
2. 在類的外部(作用域范圍外)，訪問權限才有意義：public，private，protected
3. 在類的外部，只有public修飾的成員才能被訪問，在沒有涉及繼承與派生時，

類定義的兩種方式

1.類內宣告，類外定義(一般推薦使用)

class person
{
public:
	void setperson(const char* name, int age);
	void print();
private:
	char _name[15];
	int _age;
};
 void person::setperson(const char* name, int age)//::為作用域限定符
{
	 strcpy(_name, name);
	 _age = age;

}
 void person::print()
 {
	 cout << "name:" << _name << endl;
	 cout << "age:" << _age << endl;
 }

2.類內定義

class person
{
public:
	void setperson(const char* name, int age)
	{
		strcpy(_name, name);
		_age = age;

	}
	void print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
private:
	char _name[15];
	int _age;
};

類的訪問限定符及封裝

訪問限定符的說明

1. public修飾的成員在類外可以直接被訪問
2. protected和private修飾的成員在類外不能直接被訪問(此處protected和private是類似的)
3. 訪問權限作用域從該訪問限定符出現的位置開始直到下一個訪問限定符出現時為止
4. class的默認訪問權限為private，struct為public(因為struct要兼容C)

C++中struct 和class區別是什么？

本題我會給出相對我自己的理解，或許對于剛入手C++的不是很友好，就挑自己會的記，

變數的默認方式不同

1.struct 默認變數的屬性為公有的

struct student
{
	void set(const char* name1, int age1);
	void print();
	int age;
	char name[15];
};
void student::set(const char* name1, int age1)
{
	strcpy(name, name1);
	age = age1;
}
void student::print()
{
	cout << "name" << name << endl;
	cout << "age" << age << endl;
}
void test01()
{
	student m1;
	m1.set("張三", 18);
	m1.print();
	cout << "姓名" << m1.name << endl;
	cout << "年齡" << m1.age << endl;
}

運行截圖

2.class 默認屬性為私有的

class student
{
	void set(const char* name1, int age1);
	void print();
	char name[15];
	int age;
};
void student::set(const char* name1, int age1)
{
	strcpy(name, name1);
	age = age1;
}
void student::print()
{
	cout << "name" << name << endl;
	cout << "age" << age << endl;
}
void test01()
{
	student m1;
	m1.set("張三", 18);
	m1.print();
}

我們跑一下這個程式，看下結果

可以得出結論，類默認屬性是私有的，

默認的繼承方式不同

結構體的默認繼承方式為公有繼承

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;
};
struct person :Student//給一個默認的繼承方式
{
	void set(int high1);
	void print();
	int high;
};
void person::set(int high1)
{
	high = high1;
}
void person::print()
{
	cout << "姓名" << _name << endl;
	cout << "性別" << _gender << endl;
	cout << "年齡" << _age << endl;
	cout << "身高" << high << endl;
}
void test01()
{
	
	person m2;//這里我們設定m2，
	//我們用可以用子類物件對呼叫父類的函式，說明為公有繼承
	m2.SetStudentInfo("張三", "男", 20);
	m2.set(180);
	m2.print();
}

類的默認繼承為私有繼承(當子類的物件為私有情況下，公有的依舊在子類中是公有的)

class student
{
	void set(const char* name1, int age1);
	void print();
	char name[15];
	int age;
};
void student::set(const char* name1, int age1)
{
	strcpy(name, name1);
	age = age1;
}
void student::print()
{
	cout << "name" << name << endl;
	cout << "age" << age << endl;
}
class person :student
{
	void set1(int high1);
	int high;
};
void student::set1(int high1)
{
	high = high1;
}
void test01()
{
	person m1;
	m1.set("張三", "男", 20);
	m1.set1(180);//我們使用子類的物件去呼叫父類的物件，發現錯誤
	m1.print();
}

class中可以使用模板

不做解釋，記住即可，

了解封裝

封裝：將資料和操作資料的方法進行有機結合，隱藏物件的屬性和實作細節，僅對外公開介面來和物件進行互動，
封裝本質上是一種管理：我們如何管理兵馬俑呢？比如如果什么都不管，兵馬俑就被隨意破壞了，那么我們首先建了一座房子把兵馬俑給封裝起來，但是我們目的全封裝起來，不讓別人看，所以我們開放了售票通道，可以買票突破封裝在合理的監管機制下進去參觀，類也是一樣，我們使用類資料和方法都封裝到一下，不想給別人看到的，我們使用protected/private把成員封裝起來，開放一些共有的成員函式對成員合理的訪問，所以封裝本質是一種管理

類的實體化

用型別別創建物件的程序，稱為類的實體化

1. 類只是一個模型一樣的東西，限定了類有哪些成員，定義出一個類并沒有分配實際的記憶體空間來存盤它
2. 一個類可以實體化出多個物件，實體化出的物件 占用實際的物理空間，存盤類成員變數，
3. 做個比方，類實體化出物件就像現實中使用建筑設計圖建造出房子，類就像是設計圖，只設計出需要什么東西，但是并沒有物體的建筑存在，同樣類也只是一個設計，實體化出的物件才能實際存盤資料，占用物理空間，
   
   其實這里沒什么好說的，只要記得物件在不被創建出來的時候它都是沒有空間的，
   就比如int 型別，它 自身不占空間，但是你宣告了一個int a;你再去對它求sizeof(a)；它就存在空間了，這便是型別的實體化，

類物件模型

計算一個類的大小

幾個特性：
1. 類物件的成員函式是不占空間的，
2.空類是有大小的，
3. 類中的static變數是不會被計入到類的所占空間大小中的，
1.示例代碼：

class person
{
	void set()
	{

	}
	void print()
	{

	}
	int num1;
	int num2;
	int num3;
};
void test01()
{
	cout << sizeof(person) << endl; //輸出結果為12
}

2.空類是有大小的

class person
{
	void print()
	{

	}
};
void test()
{
	cout << sizeof(person) << endl;//輸出結果為1
}
int main()
{
	test();
	return 0;
}

原因：
每個實體在記憶體中都有一個獨一無二的地址，為了達到這個目的，編譯器往往會給一個空類隱含的加一個位元組，這樣空類在實體化后在記憶體得到了獨一無二的地址，所以大小為１，
3.static 變數不屬于任何一個類

class person
{
	int age;
	int num1;
	int p;
	static int p1;
};
void test01()
{
	cout << sizeof(person) << endl;//結果為12
}
int main()
{
	test01();
	return 0;

}

結構體的記憶體對齊規則

1.從第一個屬性開始，記憶體從0開始，第二個屬性應放在**min(該屬性的大小，對齊模數)的整數倍上，
2.當所有屬性計算完成后，整體做二次偏移，當所有的屬性偏移完成后，取min（該結構體最大元素，對齊模數）**的整數倍，
給大家個代碼解釋一下吧：

eg:
struct student
{             第一次偏移       第二次偏移（起始記憶體必須是min(當前型別大小,對齊模數)整數倍）
    char a;//   0             0-3（因為要保證b的地址必須從4開始）
    int b;//    1-4           4-7
    double c;// 5-12          8-15
}
故對齊后為16位元組大小，
當調換元素順序時，其大小可能會發生改變
struct student
{  這邊直接給值，不寫分析步驟
   int b;              //0-7
   double c;           //8-15
   char a;             //16  此時占17個位元組，故結果為24位元組（記憶體對齊）
}
//故在定義結構體時在沒有特殊需求的情況下，元素應從小到大進行定義

幾道關于結構體的面試題

結構體怎么對齊？ 為什么要進行記憶體對齊

為什么要進行記憶體對齊：（自己見解）
通俗點來說，就比如說你現在1位元組1位元組的進行讀取，假如我現在記憶體中要放一個int 型別的，char型別的，double 型別的資料 ，在32位平臺下，我們只需要僅13個位元組就可以存盤完，相較于記憶體對齊的情況，我們可以省下3個位元組的大小，那為什么不這樣做呢？
解釋：如果我們需要讀取這13個位元組的資料，我們1個1個讀，會不會顯得太蠢了點，首先，從作業系統層面看，為什么要設定快取，就是為了匹配cpu讀取速度與I/o設備不匹配的問題，如果1個位元組1個位元組讀取的話，那是不是要經歷13次的訪存，這只是最理想的情況下，(在段表、頁表中訪存)需要兩次，段頁式需要三次訪存，所以，為什么要記憶體對齊的原因本質上目的是為了用空間換時間，最大化的減少cpu訪存的次數，32位的機器每次可以讀取4個位元組，最大程度上規避了多次訪存的情況，計算機自脫機處理階段開始一直都在想辦法去避免 "機等人"的現象出現，提高cpu利用率，讓cpu忙起來，
記憶體對齊原因：
1.不是所有的硬體平臺都能訪問任意地址上的任意資料的；某些硬體平臺只能在某些地址處取某些特定型別的資料，否則拋出硬體例外，
2、性能原因：經過記憶體對齊后，CPU的記憶體訪問速度（這塊我覺得應該是訪問次數）大大提升（大大減少），
怎么對齊：
1.從第一個屬性開始，記憶體從0開始，第二個屬性應放在**min(該屬性的大小，對齊模數)的整數倍上，
2.當所有屬性計算完成后，整體做二次偏移，當所有的屬性偏移完成后，取min（該結構體最大元素，對齊模數）**的整數倍，

如何讓結構體按照指定的對齊引數進行對齊

#pragma pack(num) //num為自行設定的記憶體對齊引數，但必須是2的次方倍，[0-n)

什么是大小端？如何測驗某臺機器是大端還是小端，有沒有遇到過要考慮大小端的場景

大端存盤模式：就是記憶體的低地址上存著資料的高位，高地址上存著資料的低位，
小端存盤模式：就是記憶體的低地址上存資料的低位，而高地址上存資料的高位，
大小端場景:代碼移植和網路通信，

類的成員函式到底存在什么地方？

成員函式可以被看作是類作用域的全域函式,不在物件分配的空間里,只有虛函式才會在類物件里有一個指標,存放虛函式的地址等相關資訊，成員函式的地址，編譯期就已確定，并靜態系結或動態的系結在對應的物件上，物件呼叫成員函式時，編譯器可以確定這些函式的地址，并通過傳入this指標和其他引數，完成函式的呼叫，所以類中就沒有必要存盤成員函式的資訊，這里有兩種猜測，1.多個物件共用一段相同的代碼段 2.每個物件都有自己的代碼段(每個物件的代碼段都是定義代碼段的一份拷貝)(筆者不傾向這種) 所以筆者認為此時成員函式的代碼段應放在公共代碼段中，不單單屬于某一特定物件，屬于整個物件類，
具體深入探討的話會涉及到記憶體的管理，這里就不深挖了，

this指標

c++規定，this指標是隱含在物件成員函式內的一種指標， 當一個物件被創建后，它的每一個成員函式都含有一個系統自動生成的隱含指標this，用以保存這個物件的地址， 也就是說雖然我們沒有寫上this指標，編譯器在編譯的時候也是會加上的，因此this也稱為“指向本物件的指標”，this指標并不是物件的一部分，不會影響sizeof(物件)的結果，
this指標是C++實作封裝的一種機制，它將物件和該物件呼叫的成員函式連接在一起，在外部看來，每一個物件都擁有自己的函式成員，一般情況下，并不寫this，而是讓系統進行默認設定，
this指標永遠指向當前物件，
成員函式通過this指標即可知道操作的是那個物件的資料，This指標是一種隱含指標，它隱含于每個類的非靜態成員函式中，This指標無需定義，直接使用即可，

this指標是一個 常指標

任何物件自創建之后都隱含一個this指標

struct student
{
	void set(const char* name, int age, double score)
	//void set(const char* name, int age, double score.student*const this)
	{
		strcpy(_name, name);//底層是strcpy(this->_name,name)
		_age = age;//底層是this->_age=age;
		_score = score;//底層是this->_score=score;
	}
	void print()//void print(student*const this)
	{
		cout << "name :" << _name << endl;//底層是cout<<this->_name<<endl;
		cout << "age:" << _age << endl;
		cout << "score" << _score << endl;
	}
	char _name[15];
	int _age;
	double _score;
};
void test01()
{
	student m1;
	m1.set("張三", 20, 98.9);//底層編譯器會將其變為set("張三", 20, 98.9,&m1);
	m1.print();//底層編譯器會將其變為print(&m1);
}

this指標可以為空

此時會報錯，因為this’指標是一個空指標，此時沒有空間，去獲取它里面的值，當然為錯，只是執行會出錯，在編譯階段不會報錯

struct student
{
	void set(const char* name, int age, double score)//void set(const char* name, int age, double score.student*const this)
	{
		strcpy(_name, name);//底層是strcpy(this->_name,name)
		_age = age;//底層是this->_age=age;
		_score = score;//底層是this->_score=score;
	}
	void print()//void print(student*const this)
	{
		cout << "name :" << _name << endl;//底層是cout<<this->_name<<endl;
		cout << "age:" << _age << endl;
		cout << "score" << _score << endl;
	}
	char _name[15];
	int _age;
	double _score;
};
void test02()
{
	student* m1=nullptr;
	m1->set("張三", 18, 20);
	m1->print();
}

相關面試題

this指標存在哪里？

其實編譯器在生成程式時加入了獲取物件首地址的相關代碼，并把獲取的首地址存放在了暫存器ECX中(VC++編譯器是放在ECX中，其它編譯器有可能不同)，也就是成員函式的其它引數正常都是存放在堆疊中，而this指標引數則是存放在暫存器中，類的靜態成員函式因為沒有this指標這個引數，所以類的靜態成員函式也就無法呼叫類的非靜態成員變數，

this指標可以為空嗎

上面已經給出了解答，
可以為空，當我們呼叫函式時，如果函式內部不需要使用到this,也就是不需要通過this指向當前物件并對其進行操作時才可以為空(當我們在其中什么都不放或者在里面隨便列印一個字串)，如果呼叫的函式需要指向當前物件，并進行操作，則會發生錯誤（空指標參考）就跟C中一樣不能進行空指標的參考