函數(shù)重載是函數(shù)的一種特殊情況，C++允許在同一作用域中聲明幾個功能類似的同名函數(shù)，這些同名函數(shù)的形參列表（參數(shù)個數(shù)或類型或類型順序）不同，常用來處理實現(xiàn)功能類似數(shù)據(jù)類型不同的問題。

#includeusing namespace std;
// 1、參數(shù)類型不同
int Add(int left, int right)
{
	cout<< left + right<< endl;
	return left + right;
}
double Add(double left, double right)
{
	cout<< left + right<< endl;
	return left + right;
}
// 2、參數(shù)個數(shù)不同
void f()
{
	cout<< "f()"<< endl;
}
void f(int a)
{
	cout<< "f(int a)"<< endl;
}
// 3、參數(shù)類型順序不同
void f(int a, char b)
{
	cout<< "f(int a,char b)"<< endl;
}
void f(char b, int a)
{
	cout<< "f(char b, int a)"<< endl;
}
int main()
{
	Add(1, 2);
	Add(1.1, 2.2);
	f();
	f(10);
	f(10, 'a');
	f('a', 10);
	return 0;
}

為什么C++支持函數(shù)重載而C語言不支持函數(shù)重載呢？

????????在C/C++中，一個程序要運行起來，需要經(jīng)歷以下幾個階段：預處理、編譯、匯編、鏈接。在編譯階段，編譯器會匯總全局的符號，如main函數(shù)、全局變量、函數(shù)名等；然后在匯編階段，編譯器會給編譯時匯總的每個符號分配一個地址(注意如果符號只是聲明則會分配一個無效的地址)，并且在對應的.o文件中形成一個符號表；各個.o文件的符號表在鏈接時會合并，并且在合并時同名的符號會選擇有效的地址進行合并。

? 在C語言當中，C語言的編譯器并不會根據(jù)函數(shù)參數(shù)的特性對函數(shù)名進行修飾；這就導致即使函數(shù)形參列表不同只要函數(shù)名相同，那么符號匯總時就會出現(xiàn)同名的符號，這時編譯器就會報錯。

? 在C++中，同名的函數(shù)只要形參列表不同，C++編譯器會根據(jù)名字修飾規(guī)則對函數(shù)名進行修飾，這時在編譯時同名但形參列表不同的函數(shù)就會形成不同的符號；既然不出現(xiàn)同名符號，編譯器自然不會報相應的錯誤。

? 如果兩個函數(shù)函數(shù)名和參數(shù)是一樣的，返回值不同是不構成重載的，因為調(diào)用是存在二義性，編譯器無法區(qū)分。

注意：不同平臺的C++編譯器的名字修飾規(guī)則不一樣，但是產(chǎn)生的效果是一樣的。

以inline修飾的函數(shù)叫做內(nèi)聯(lián)函數(shù)，編譯時C++編譯器會在調(diào)用內(nèi)聯(lián)函數(shù)的地方展開，沒有函數(shù)調(diào)用建立棧幀的開銷，內(nèi)聯(lián)函數(shù)提升程序運行的效率。

如果在上述函數(shù)前增加?inline?關鍵字將其改成內(nèi)聯(lián)函數(shù)，在編譯期間編譯器會用函數(shù)體替換函數(shù)的調(diào)用。

查看方式：

1. 在release模式下，查看編譯器生成的匯編代碼中是否存在call Add
2. 在debug模式下，需要對編譯器進行設置，否則不會展開(因為debug模式下，編譯器默認不 會對代碼進行優(yōu)化，以下給出vs2013的設置方式)

1. inline是一種以空間換時間的做法，如果編譯器將函數(shù)當成內(nèi)聯(lián)函數(shù)處理，在編譯階段，會 用函數(shù)體替換函數(shù)調(diào)用.缺陷：可能會使目標文件變大;優(yōu)勢：少了調(diào)用開銷，提高程序運行效率。
2. inline對于編譯器而言只是一個建議，不同編譯器關于inline實現(xiàn)機制可能不同，一般建議：將函數(shù)規(guī)模較小(即函數(shù)不是很長，具體沒有準確的說法，取決于編譯器內(nèi)部實現(xiàn))、不是遞歸、且頻繁調(diào)用的函數(shù)采用inline修飾，否則編譯器會忽略inline特性。

在《C++prime》第五版中關于inline的建議：

內(nèi)聯(lián)說明只是向編譯器發(fā)出一個請求，編譯器可以選擇忽略這個請求。

一般來說，內(nèi)聯(lián)機制用于優(yōu)化規(guī)模較小、流程直接、頻繁調(diào)用的函數(shù)。很多編譯器都不支持內(nèi)聯(lián)遞歸函數(shù)，而且一個75行的函數(shù)也不太可能在調(diào)用點內(nèi)聯(lián)展開(75不是編譯器規(guī)定的)。

3.inline不建議聲明和定義分離，分離會導致鏈接錯誤。因為inline被展開，就沒有函數(shù)地址 了，鏈接就會找不到。

注意：

當內(nèi)聯(lián)函數(shù)太長，編譯不會將其在調(diào)用內(nèi)聯(lián)函數(shù)的地方展開；此時函數(shù)相當于一個正常的函數(shù)，編譯器給該函數(shù)符號分配地址合成在符號表中，然后通過符號表調(diào)用該函數(shù)。

說明：func是一個很長的函數(shù)。

如上圖所示，當內(nèi)聯(lián)函數(shù)很長時，編譯器不會在調(diào)用內(nèi)聯(lián)函數(shù)的地方展開 ，可以看到內(nèi)聯(lián)函數(shù)會分配一個地址，然后編譯器調(diào)通過地址調(diào)用該內(nèi)聯(lián)函數(shù)。

【面試題】

1. 宏的優(yōu)缺點？

優(yōu)點：

1. 增強代碼的復用性；
2. 提高性能。

缺點：

1. 不方便調(diào)試宏；（因為預編譯階段進行了替換）
2. 導致代碼可讀性差，可維護性差，容易誤用；
3. 沒有類型安全檢查。

2. C++有哪些技術替換宏？

1. 常量定義換用 const enum；
2. 短小函數(shù)定義 換用內(nèi)聯(lián)函數(shù)。

隨著程序越來越復雜，程序中用到的類型也越來越復雜，經(jīng)常體現(xiàn)在：

1. 類型難于拼寫
2. 含義不明確導致容易出錯

//這是一個例子
//下面的代碼不一定認識
//但是這是C++的代碼
#include#include

可以看到上述代碼中：

//這是一個類型，但是該類型太長，容易寫錯
std::map::iterator

我們可以使用typedef給類型取別名以簡化代碼，但是typedef有會遇到新的難題：

//如：typedef std::map::iterator iterator;


typedef char* pstring;
int main()
{
 const pstring p1;    // 編譯成功還是失??？
 const pstring* p2;   // 編譯成功還是失??？
 return 0;
}

在編程時，常常需要把表達式的值賦值給變量，這就要求在聲明變量的時候清楚地知道表達式的 類型。然而有時候要做到這點并非那么容易，因此C++11給auto賦予了新的含義。

在早期C/C++中auto的含義是：使用auto修飾的變量，是具有自動存儲器的局部變量。

C++11中，標準委員會賦予了auto全新的含義即：auto不再是一個存儲類型指示符，而是作為一 個新的類型指示符來指示編譯器，auto聲明的變量必須由編譯器在編譯時期推導而得。

#includeusing namespace std;

int TestAuto()
{
    return 10;
}

//typeid().name() 用來求變量的類型對于的字符串
int main()
{
    int a = 10;
    auto b = a;
    auto c = 'a';
    auto d = TestAuto();
    cout<< typeid(b).name()<< endl;
    cout<< typeid(c).name()<< endl;
    cout<< typeid(d).name()<< endl;
    //auto e; 無法通過編譯，使用auto定義變量時必須對其進行初始化
    return 0;
}

運行程序，可以看到下圖：??

【注意】

使用auto定義變量時必須對其進行初始化，在編譯階段編譯器需要根據(jù)初始化表達式來推導auto 的實際類型。因此auto并非是一種“類型”的聲明，而是一個類型聲明時的“占位符”，編譯器在編 譯期會將auto替換為變量實際的類型。

? 用auto聲明指針類型時，用auto和auto*沒有任何區(qū)別，但用auto聲明引用類型時則必須加&。

#includeusing namespace std;

int main()
{
    int x = 10;
    auto a = &x;
    auto* b = &x;
    auto& c = x;
    cout<< typeid(a).name()<< endl;
    cout<< typeid(b).name()<< endl;
    cout<< typeid(c).name()<< endl;
    *a = 20;
    *b = 30;
    c = 40;
    return 0;
}

當在同一行聲明多個變量時，這些變量必須是相同的類型，否則編譯器將會報錯，因為編譯 器實際只對第一個類型進行推導，然后用推導出來的類型定義其他變量。

void TestAuto()
{
    auto a = 1, b = 2; 
    auto c = 3, d = 4.0;  // 該行代碼會編譯失敗，因為c和d的初始化表達式類型不同
}

上述代碼編譯會出錯，如下圖所示：?

1. auto不能作為函數(shù)的參數(shù)；

auto不能作為形參類型，因為編譯器無法對形參的實際類型進行推導。

2. auto不能直接用來聲明數(shù)組；

3.?為了避免與C++98中的auto發(fā)生混淆，C++11只保留了auto作為類型指示符的用法；

4. auto在實際中最常見的優(yōu)勢用法就是跟以后會講到的C++11提供的新式for循環(huán)，還有 lambda表達式等進行配合使用。

在C++98中如果要遍歷一個數(shù)組，可以按照以下方式進行：

void TestFor()
{
    int array[] = { 1, 2, 3, 4, 5 };

    for (int i = 0; i< sizeof(array) / sizeof(array[0]); ++i)
         array[i] *= 2;

    for (int* p = array; p< array + sizeof(array)/ sizeof(array[0]); ++p)
         cout<< *p<< endl;
}

對于一個有范圍的集合而言，由程序員來說明循環(huán)的范圍是多余的，有時候還會容易犯錯誤。因 此C++11中引入了基于范圍的for循環(huán)。for循環(huán)后的括號由冒號“ ：”分為兩部分：第一部分是范 圍內(nèi)用于迭代的變量，第二部分則表示被迭代的范圍。

void TestFor()
{
    int array[] = { 1, 2, 3, 4, 5 };
    for(auto& e : array)
        e *= 2;
    //注意下面代碼中e是數(shù)組元素的拷貝，改變e不會改變數(shù)組當中的元素
    for(auto e : array)  
         cout<< e<< " ";
}

注意：與普通循環(huán)類似，可以用continue來結束本次循環(huán)，也可以用break來跳出整個循環(huán)。??

上述程序同樣可以遍歷數(shù)組，使用引用可以改變數(shù)組的值；

1. for循環(huán)迭代的范圍必須是確定的；

對于數(shù)組而言，就是數(shù)組中第一個元素和最后一個元素的范圍；對于類而言，應該提供begin? ? ? ? ? 和end的方法，begin和end就是for循環(huán)迭代的范圍。

//注意：以下代碼就有問題，因為for的范圍不確定
void TestFor(int array[])
{
    for(auto& e : array)
        cout<< e<

2. 迭代的對象要實現(xiàn)++和==的操作。（了解一下就行）?

void TestPtr()
{
int* p1 = NULL;
int* p2 = 0;
// ……
}

#ifndef NULL
#ifdef __cplusplus  //C++中NULL為0，而不是空指針
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

#includeusing namespace std;

void f(int)
{
     cout<<"f(int)"<