缺省參數(shù)分類

• 全缺省參數(shù)

  對所有參數(shù)都設(shè)置了備胎：

  void TestFunc(int a = 10, int b = 20, int c = 30){	cout<<"a = "<void TestFunc(int a, int b = 10, int c = 20){   cout<<"a = "<void TestFunc(int a = 10, int b = 20, int c)

  否則在傳參的時候， TestFunc(10, 20);不知道參數(shù)是給哪個形參的

• 沒有缺省必須要傳參。

  比如我們定義了這樣一個缺省函數(shù)：

  void TestFunc(int a, int b = 10, int c = 20){  cout<<"a = "<//a.hvoid TestFunc(int a = 10);	// a.cvoid TestFunc(int a = 20){}// 注意：如果聲明與定義位置同時出現(xiàn)，恰巧兩個位置提供的值不同，那編譯器就無法確定到底該用那個缺省值。

  4. 缺省值必須是常量或者全局變量
  5. C語言不支持（編譯器不支持）

  ?

  函數(shù)重載

  函數(shù)重載就是同一個函數(shù)名可以多次創(chuàng)建使用，但需要符合一定的條件。

  函數(shù)重載概念

  函數(shù)重載:是函數(shù)的一種特殊情況，C++允許在同一作用域中聲明幾個功能類似的同名函數(shù)，這些同名函數(shù)的
  形參列表(參數(shù)個數(shù) 或 類型 或 順序)必須不同，返回類型可以不同，但前面幾個一定要有一個或多個不同。常用來處理實現(xiàn)功能類似數(shù)據(jù)類型不同的問題。

  int Add(int left, int right){    return left+right;}double Add(double left, double right){	return left+right;}long Add(long left, long right){	return left+right;}int main(){	Add(10, 20);	Add(10.0, 20.0);	Add(10L, 20L);	return 0;}

  下面兩個函數(shù)屬于函數(shù)重載嗎？

  short Add(short left, short right){	return left+right;}int Add(short left, short right){	return left+right;}

  答案是：不屬于。

  雖然返回類型不同，但形參的類型，順序，個數(shù)都是相同的，所以這兩個函數(shù)不屬于函數(shù)重載。

  名字修飾(name Mangling)

  為什么C++支持函數(shù)重載，而C語言不支持函數(shù)重載呢？
  在C/C++中，一個程序要運行起來，需要經(jīng)歷以下幾個階段：預(yù)處理、編譯、匯編、鏈接。

  1. 實際我們的項目通常是由多個頭文件和多個源文件構(gòu)成，而通過我們C語言階段學(xué)習(xí)的編譯鏈接，我們
     可以知道，【當(dāng)前a.cpp中調(diào)用了b.cpp中定義的Add函數(shù)時】，編譯后鏈接前，a.o的目標(biāo)文件中沒有
     Add的函數(shù)地址，因為Add是在b.cpp中定義的，所以Add的地址在b.o中。那么怎么辦呢？
  2. 所以鏈接階段就是專門處理這種問題，鏈接器看到a.o調(diào)用Add，但是沒有Add的地址，就會到b.o的符
     號表中找Add的地址，然后鏈接到一起。
  3. 那么鏈接時，面對Add函數(shù)，連接器會使用哪個名字去找呢？這里每個編譯器都有自己的函數(shù)名修飾規(guī)
     則。
  4. 由于Windows下vs的修飾規(guī)則過于復(fù)雜，而Linux下gcc的修飾規(guī)則簡單易懂，下面我們使用了gcc演示
     了這個修飾后的名字。
  5. 通過下面我們可以看出gcc的函數(shù)修飾后名字不變。而g++的函數(shù)修飾后變成【_Z+函數(shù)長度+函數(shù)名+類
     型首字母】

  • 采用C語言編譯器編譯后結(jié)果

    可以看到C語言編譯后生成的函數(shù)名字與原名相同，其實是生成的符號表中，Add、func的名稱就是原名。

  • 采用C++編譯器編譯后結(jié)果

    而C++經(jīng)過編譯后，生成的符號表中對應(yīng)Add、func的名稱是經(jīng)過修飾的，所以支持重載函數(shù)。

    結(jié)論：在linux下，采用g++編譯完成后，函數(shù)名字的修飾發(fā)生改變，編譯器將函數(shù)參數(shù)類型信息添加到修改后的名字中

  6. 通過這里就理解了C語言沒辦法支持重載，因為同名函數(shù)沒辦法區(qū)分。而C++是通過函數(shù)修飾規(guī)則來區(qū)
     分，只要參數(shù)不同，修飾出來的名字就不一樣，就支持了重載。

  7. 函數(shù)名相同、參數(shù)類型、順序相同，返回類型不同可以構(gòu)成重載嗎？

     不能，如果把返回值帶進修飾規(guī)則，那么編譯器層面是可以區(qū)分的。但是語法調(diào)用層面，很難區(qū)分，帶有嚴(yán)重的歧義。

     比如無參函數(shù)fun()，如果一個返回值是int，一個是double，這如何區(qū)分呢。

  關(guān)于重載的問題：

  1. 下面兩個函數(shù)能形成函數(shù)重載嗎？有問題嗎或者什么情況下會出問題？

     void TestFunc(int a = 10){	 cout<<"void TestFunc(int)"<

     不能形成函數(shù)重載，函數(shù)的形參個數(shù)、類型、順序都相同，不符合重載函數(shù)的必備條件

  2. C語言中為什么不能支持函數(shù)重載？

     C語言編譯時生成的符號表中，函數(shù)的名字就是原名，沒有修飾，因此只能一個函數(shù)名只能對應(yīng)一個函數(shù)。

  3. C++中函數(shù)重載底層是怎么處理的？

     C++與C語言不同，C++編譯時生成的符號表中，函數(shù)名稱是經(jīng)過修飾的，修飾包括函數(shù)的參數(shù)類型、順序，所以對相同地函數(shù)名，如果形參的順序、個數(shù)、類型不同，就可以實現(xiàn)重載函數(shù)。

  4. C++中能否將一個函數(shù)按照C的風(fēng)格來編譯？

     能，因為C++是支持C的語法的。

  extern C

  有時候在C++工程中可能需要將某些函數(shù)按照C的風(fēng)格來編譯，在函數(shù)前加extern “C”，意思是告訴編譯器，將該函數(shù)按照C語言規(guī)則來編譯。比如：tcmalloc是google用C++實現(xiàn)的一個項目，他提供tcmallc()和tcfree兩個接口來使用，但如果是C項目就沒辦法使用，那么就需要使用extern “C”來解決。

  C語言實現(xiàn)的模塊是放在靜態(tài)庫或者動態(tài)庫里的，因此編譯時引用里面的模塊，名稱是不能直接識別的，而C++是兼容C的，想要C++也使用該模塊，就要使用extern “C”。

  使用格式：

  例如：extern “C” int Add(int left, int right)

  關(guān)于extern "C"的更多內(nèi)容，可以百度答案：[extern “C”_百度百科 (baidu.com)](https://baike.baidu.com/item/extern “C”/15267013)

  引用

  引用就像給變量取別名，不會重新開辟空間，只是使變量多了一個名稱。

  類型& 引用變量名(對象名) = 引用實體

  void TestRef(){	int a = 10;	int& ra = a;//<====定義引用類型	printf("%p/n", &a);	printf("%p/n", &ra);}

  注意：引用類型必須和引用實體是同種類型的

  引用特性

  1. 引用在定義時必須初始化
  2. 一個變量可以有多個引用
  3. 引用一旦引用一個實體，再不能引用其他實體

  void TestRef(){	int a = 10;	// int& ra; // 該條語句編譯時會出錯	int& ra = a;	int& rra = a;	printf("%p %p %p/n", &a, &ra, &rra);}

  這一段代碼是將b的值賦給c，還是使c變成b的引用？

  	int a = 1;	int&c = a;	int b = 2;	c = b;

  根據(jù)上面的特性3，c = b是將b的值賦給c，而不是使c再變成b的引用。

  指針的引用：

  int main(){	int x = 10;	int y = 20;	int* p1 = &x;	int* p2 = &y;	int*& p3 = p1;//p3是p1的別名        *p3 = 20;//x的值被改為20    p3 = p2;//p1、p3改變指向，指向了y	return 0;}

  *p3 = 20前：

  x = 10

  *p3 = 20后：

  x = 20

  p3 = p2前：

  p1、p3指向x，p2指向y

  p3 = p2后：

  p1、p3都指向了y

  常引用

  常引用類似C語言中指針加const。

  void TestConstRef(){	const int a = 10;	//int& ra = a; // 該語句編譯時會出錯，a為常量，這么做是權(quán)限的放大	const int& ra = a;//正確引用	// int& b = 10; // 該語句編譯時會出錯，b為常量，同樣是權(quán)限的放大	const int& b = 10;//正確引用	double d = 12.34;	//int& rd = d; // 該語句編譯時會出錯，類型不同，經(jīng)轉(zhuǎn)換后沒有修改內(nèi)存中的內(nèi)容的權(quán)力	const int& rd = d;}

  指針中：

  1.	int a = 10;	const int*cp1 = &a;	int *p1 = cp1;//不行，因為cp1指向的內(nèi)容都是不可以修改的，p1這個例子是權(quán)限的放大2.	int a = 10;	int *p1 = &a;	const int*cp1 = p;//可以，p1指向的內(nèi)容是可以修改的，cp1是權(quán)限的縮小，沒問題。

  我們分析一下最后一個例子：

  	double d = 12.34;	//int& rd = d; // 該語句編譯時會出錯，類型不同	const int& rd = d;

  為什么加上const后就可以了呢？

  我們先看這段代碼：

  	double d = 12.34;	int a = d;

  這段代碼會發(fā)生一個隱式類型轉(zhuǎn)換，而隱式類型轉(zhuǎn)換實際上是產(chǎn)生一個int類型的臨時變量，該變量是常變量。再將常變量的值賦給a，a的內(nèi)存是新開辟的內(nèi)存。而如果是引用：const int& rd = d;就必須要加上const修飾，被轉(zhuǎn)換之后，該值只能被讀取而不能修改，因為rd使用的是臨時變量的內(nèi)存，臨時變量具有常屬性，是不能修改的。

  總結(jié)：引用取別名時，變量訪問的權(quán)限可以縮小，不能放大。

  引用使用場景

  1. 做參數(shù)

     void Swap(int& left, int& right){	int temp = left;	left = right;	right = temp;}

     left和right是實參的別名，不同于指針，在Swap里修改了left和right就是修改了實參

     作用：

     1. 輸出型參數(shù)
     2. 提高效率

  2. 做返回值

     int Count1(){	static int n = 0；	n++;	// ...	return n;}int& Count2(){	static int n = 0；	n++;	// ...	return n;}int main(){	int& r1 = Count1();//不可以，Count1返回值是一個常變量	int& r2 = Count2();//可以，Count2的返回值是n的別名}

     返回值返回的是臨時變量（具有常屬性）

     Count1：會開辟一塊空間給tmp：int tmp = n，tmp是常變量，不可被修改，所以用const

     Count2：int& tmp = n，tmp是n的別名，但實際上這么寫是內(nèi)存的非法訪問，n的內(nèi)存實際上以及不能再使用了，但那塊內(nèi)存的值還存在

     r1不行，r2可以

     作用：少創(chuàng)建一個臨時拷貝對象，提高效率

     而當(dāng)代碼變?yōu)橄旅孢@樣時，使用引用返回就不安全，因為c不再是靜態(tài)變量，而是一個局部變量，當(dāng)Add返回時，Add函數(shù)的空間已經(jīng)返回給操作系統(tǒng)了，那塊系統(tǒng)還在，只是使用權(quán)已經(jīng)不是我們的了。

     int& Add(int a, int b){	int c = a + b;	return c;}int main(){	int& ret = Add(1, 2);	Add(3, 4);	cout << "Add(1, 2) is :"<< ret <

  一個函數(shù)要使用引用返回，返回變量出了這個函數(shù)的作用域還存在，就可以使用引用返回，否則就不安全，就必須使用傳值返回

  傳值、傳引用效率比較

  以值作為參數(shù)或者返回值類型，在傳參和返回期間，函數(shù)不會直接傳遞實參或者將變量本身直接返回，而是
  傳遞實參或者返回變量的一份臨時的拷貝，因此用值作為參數(shù)或者返回值類型，效率是非常低下的，尤其是
  當(dāng)參數(shù)或者返回值類型非常大時，效率就更低。

  #include struct A { 	int a[10000]; };void TestFunc1(A a) {	;}void TestFunc2(A& a) {	;}void TestRefAndValue(){	A a;	// 以值作為函數(shù)參數(shù)	size_t begin1 = clock();	for (size_t i = 0; i < 100000; ++i)		TestFunc1(a);	size_t end1 = clock();	// 以引用作為函數(shù)參數(shù)	size_t begin2 = clock();	for (size_t i = 0; i < 100000; ++i)		TestFunc2(a);	size_t end2 = clock();	// 分別計算兩個函數(shù)運行結(jié)束后的時間	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;}int main(){	TestRefAndValue();	return 0;}

  測評效果：

  由此可知，以引用做參數(shù)的效率比傳值做參數(shù)的效率快了，省去了參數(shù)拷貝的時間開銷

  值和引用的作為返回值類型的性能比較

  #include struct A { 	int a[10000]; };A a;// 值返回A TestFunc1() { 	return a;}// 引用返回A& TestFunc2() { 	return a; }void TestReturnByRefOrValue(){	// 以值作為函數(shù)的返回值類型	size_t begin1 = clock();	for (size_t i = 0; i < 100000; ++i)		TestFunc1();	size_t end1 = clock();	// 以引用作為函數(shù)的返回值類型	size_t begin2 = clock();	for (size_t i = 0; i < 100000; ++i)		TestFunc2();	size_t end2 = clock();	// 計算兩個函數(shù)運算完成之后的時間	cout << "TestFunc1 time:" << end1 - begin1 << endl;	cout << "TestFunc2 time:" << end2 - begin2 << endl;}int main(){	TestReturnByRefOrValue();	return 0;}

  測評效果：

  通過結(jié)果我們可以發(fā)現(xiàn)引用返回效率比值返回效率高了很多，省去了返回值的拷貝

  引用和指針的區(qū)別

  在語法概念上引用就是一個別名，沒有獨立空間，和其引用實體共用同一塊空間。

  int main(){	int a = 10;	int& ra = a;	cout<<"&a = "<<&a<int main(){	int a = 10;	int& ra = a;	ra = 20;	int* pa = &a;	*pa = 20;	return 0;}

  我們來看下引用和指針的匯編代碼對比：

  可以觀察到實際上b和p在匯編時執(zhí)行的內(nèi)容是一樣的，只不過我們在語法理解時，是b沒有開辟新空間，只是a的一個別名，而指針p是開辟了空間保存a的地址的。

  引用和指針的不同點:

  1. 引用在定義時必須初始化，指針沒有要求
  2. 引用在初始化時引用一個實體后，就不能再引用其他實體，而指針可以在任何時候指向任何一個同類型
     實體
  3. 沒有NULL引用，但有NULL指針
  4. 在sizeof中含義不同：引用結(jié)果為引用類型的大小，但指針始終是地址空間所占字節(jié)個數(shù)(32位平臺下占
     4個字節(jié))
  5. 引用自加即引用的實體增加1，指針自加即指針向后偏移一個類型的大小
  6. 有多級指針，但是沒有多級引用
  7. 訪問實體方式不同，指針需要顯式解引用，引用編譯器自己處理
  8. 引用比指針使用起來相對更安全