相對而言，C語言和C++相關(guān)的面試題比較少見，沒有Java方向?qū)懙娜四敲炊?，這是一篇 C 語言與 C++面試知識點總結(jié)的文章，個人感覺非常難得，希望能對大家有所幫助。

const

作用

1. 修飾變量，說明該變量不可以被改變；

2. 修飾指針，分為指向常量的指針（pointer to const）和自身是常量的指針（常量指針，const pointer）；

3. 修飾引用，指向常量的引用（reference to const），用于形參類型，即避免了拷貝，又避免了函數(shù)對值的修改；

4. 修飾成員函數(shù)，說明該成員函數(shù)內(nèi)不能修改成員變量。

const 的指針與引用

1. 指針

• 指向常量的指針（pointer to const）
• 自身是常量的指針（常量指針，const pointer）

2. 引用

• 指向常量的引用（reference to const）
• 沒有 const reference，因為引用本身就是 const pointer

（為了方便記憶可以想成）被 const 修飾（在 const 后面）的值不可改變，如下文使用例子中的 p2、p3。

使用

// 類
class A
{
private:
  const int a;        // 常對象成員，只能在初始化列表賦值

public:
  // 構(gòu)造函數(shù)
  A() : a(0) { };
  A(int x) : a(x) { };    // 初始化列表

  // const可用于對重載函數(shù)的區(qū)分
  int getValue();       // 普通成員函數(shù)
  int getValue() const;    // 常成員函數(shù)，不得修改類中的任何數(shù)據(jù)成員的值
};

void function()
{
  // 對象
  A b;            // 普通對象，可以調(diào)用全部成員函數(shù)、更新常成員變量
  const A a;         // 常對象，只能調(diào)用常成員函數(shù)
  const A *p = &a;      // 指針變量，指向常對象
  const A &q = a;       // 指向常對象的引用

  // 指針
  char greeting[] = "Hello";
  char* p1 = greeting;        // 指針變量，指向字符數(shù)組變量
  const char* p2 = greeting;     // 指針變量，指向字符數(shù)組常量（const 后面是 char，說明指向的字符（char）不可改變）
  char* const p3 = greeting;     // 自身是常量的指針，指向字符數(shù)組變量（const 后面是 p3，說明 p3 指針自身不可改變）
  const char* const p4 = greeting;  // 自身是常量的指針，指向字符數(shù)組常量
}

// 函數(shù)
void function1(const int Var);      // 傳遞過來的參數(shù)在函數(shù)內(nèi)不可變
void function2(const char* Var);     // 參數(shù)指針所指內(nèi)容為常量
void function3(char* const Var);     // 參數(shù)指針為常量
void function4(const int& Var);     // 引用參數(shù)在函數(shù)內(nèi)為常量

// 函數(shù)返回值
const int function5();   // 返回一個常數(shù)
const int* function6();   // 返回一個指向常量的指針變量，使用：const int *p = function6();
int* const function7();   // 返回一個指向變量的常指針，使用：int* const p = function7();

static

作用

1. 修飾普通變量，修改變量的存儲區(qū)域和生命周期，使變量存儲在靜態(tài)區(qū)，在 main 函數(shù)運行前就分配了空間，如果有初始值就用初始值初始化它，如果沒有初始值系統(tǒng)用默認值初始化它。

2. 修飾普通函數(shù)，表明函數(shù)的作用范圍，僅在定義該函數(shù)的文件內(nèi)才能使用。在多人開發(fā)項目時，為了防止與他人命名空間里的函數(shù)重名，可以將函數(shù)定位為 static。

3. 修飾成員變量，修飾成員變量使所有的對象只保存一個該變量，而且不需要生成對象就可以訪問該成員。

4. 修飾成員函數(shù)，修飾成員函數(shù)使得不需要生成對象就可以訪問該函數(shù)，但是在 static 函數(shù)內(nèi)不能訪問非靜態(tài)成員。

this 指針

1. this 指針是一個隱含于每一個非靜態(tài)成員函數(shù)中的特殊指針。它指向調(diào)用該成員函數(shù)的那個對象。

2. 當對一個對象調(diào)用成員函數(shù)時，編譯程序先將對象的地址賦給 this 指針，然后調(diào)用成員函數(shù)，每次成員函數(shù)存取數(shù)據(jù)成員時，都隱式使用 this 指針。

3. 當一個成員函數(shù)被調(diào)用時，自動向它傳遞一個隱含的參數(shù)，該參數(shù)是一個指向這個成員函數(shù)所在的對象的指針。

4. this 指針被隱含地聲明為: ClassNameconst this，這意味著不能給 this 指針賦值；在 ClassName 類的 const 成員函數(shù)中，this 指針的類型為：const ClassNameconst，這說明不能對 this 指針所指向的這種對象是不可修改的（即不能對這種對象的數(shù)據(jù)成員進行賦值操作）；

5. this 并不是一個常規(guī)變量，而是個右值，所以不能取得 this 的地址（不能 &this）。

在以下場景中，經(jīng)常需要顯式引用 this 指針：

• 為實現(xiàn)對象的鏈式引用；
• 為避免對同一對象進行賦值操作；
• 在實現(xiàn)一些數(shù)據(jù)結(jié)構(gòu)時，如 list。

inline 內(nèi)聯(lián)函數(shù)

特征

• 相當于把內(nèi)聯(lián)函數(shù)里面的內(nèi)容寫在調(diào)用內(nèi)聯(lián)函數(shù)處；
• 相當于不用執(zhí)行進入函數(shù)的步驟，直接執(zhí)行函數(shù)體；
• 相當于宏，卻比宏多了類型檢查，真正具有函數(shù)特性；
• 編譯器一般不內(nèi)聯(lián)包含循環(huán)、遞歸、switch 等復(fù)雜操作的內(nèi)聯(lián)函數(shù)；
• 在類聲明中定義的函數(shù)，除了虛函數(shù)的其他函數(shù)都會自動隱式地當成內(nèi)聯(lián)函數(shù)。

使用

inline 使用

// 聲明1（加 inline，建議使用）
inline int functionName(int first, int second,...);

// 聲明2（不加 inline）
int functionName(int first, int second,...);

// 定義
inline int functionName(int first, int second,...) {/****/};

// 類內(nèi)定義，隱式內(nèi)聯(lián)
class A {
  int doA() { return 0; }     // 隱式內(nèi)聯(lián)
}

// 類外定義，需要顯式內(nèi)聯(lián)
class A {
  int doA();
}
inline int A::doA() { return 0; }  // 需要顯式內(nèi)聯(lián)

編譯器對 inline 函數(shù)處理步驟

1. 將 inline 函數(shù)體復(fù)制到 inline 函數(shù)調(diào)用點處；
2. 為所用 inline 函數(shù)中的局部變量分配內(nèi)存空間；
3. 將 inline 函數(shù)的的輸入?yún)?shù)和返回值映射到調(diào)用方法的局部變量空間中；
4. 如果 inline 函數(shù)有多個返回點，將其轉(zhuǎn)變?yōu)?inline 函數(shù)代碼塊末尾的分支（使用 GOTO）。

優(yōu)缺點

---

優(yōu)點

• 內(nèi)聯(lián)函數(shù)同宏函數(shù)一樣將在被調(diào)用處進行代碼展開，省去了參數(shù)壓棧、棧幀開辟與回收，結(jié)果返回等，從而提高程序運行速度。
• 內(nèi)聯(lián)函數(shù)相比宏函數(shù)來說，在代碼展開時，會做安全檢查或自動類型轉(zhuǎn)換（同普通函數(shù)），而宏定義則不會。
• 在類中聲明同時定義的成員函數(shù)，自動轉(zhuǎn)化為內(nèi)聯(lián)函數(shù)，因此內(nèi)聯(lián)函數(shù)可以訪問類的成員變量，宏定義則不能。
• 內(nèi)聯(lián)函數(shù)在運行時可調(diào)試，而宏定義不可以。

虛函數(shù)（virtual）可以是內(nèi)聯(lián)函數(shù)（inline）嗎？

---

Are "inline virtual" member functions ever actually "inlined"?

• 虛函數(shù)可以是內(nèi)聯(lián)函數(shù)，內(nèi)聯(lián)是可以修飾虛函數(shù)的，但是當虛函數(shù)表現(xiàn)多態(tài)性的時候不能內(nèi)聯(lián)。
• 內(nèi)聯(lián)是在編譯器建議編譯器內(nèi)聯(lián)，而虛函數(shù)的多態(tài)性在運行期，編譯器無法知道運行期調(diào)用哪個代碼，因此虛函數(shù)表現(xiàn)為多態(tài)性時（運行期）不可以內(nèi)聯(lián)。
• inline virtual 唯一可以內(nèi)聯(lián)的時候是：編譯器知道所調(diào)用的對象是哪個類（如 Base::who()），這只有在編譯器具有實際對象而不是對象的指針或引用時才會發(fā)生。

虛函數(shù)內(nèi)聯(lián)使用

#include 
using namespace std;
class Base
{
public:
inline virtual void who()
{
cout << "I am Base
";
}
virtual ~Base() {}
};
class Derived : public Base
{
public:
inline void who() ?// 不寫inline時隱式內(nèi)聯(lián)
{
cout << "I am Derived
";
}
};

int main()
{
// 此處的虛函數(shù) who()，是通過類（Base）的具體對象（b）來調(diào)用的，編譯期間就能確定了，所以它可以是內(nèi)聯(lián)的，但最終是否內(nèi)聯(lián)取決于編譯器。
Base b;
b.who();

// 此處的虛函數(shù)是通過指針調(diào)用的，呈現(xiàn)多態(tài)性，需要在運行時期間才能確定，所以不能為內(nèi)聯(lián)。
Base *ptr = new Derived();
ptr->who();

// 因為Base有虛析構(gòu)函數(shù)（virtual ~Base() {}），所以 delete 時，會先調(diào)用派生類（Derived）析構(gòu)函數(shù)，再調(diào)用基類（Base）析構(gòu)函數(shù)，防止內(nèi)存泄漏。
delete ptr;
ptr = nullptr;

system("pause");
return 0;
}

volatile

volatile int i = 10;

• volatile 關(guān)鍵字是一種類型修飾符，用它聲明的類型變量表示可以被某些編譯器未知的因素（操作系統(tǒng)、硬件、其它線程等）更改。所以使用 volatile 告訴編譯器不應(yīng)對這樣的對象進行優(yōu)化。
• volatile 關(guān)鍵字聲明的變量，每次訪問時都必須從內(nèi)存中取出值（沒有被 volatile 修飾的變量，可能由于編譯器的優(yōu)化，從 CPU 寄存器中取值）
• const 可以是 volatile （如只讀的狀態(tài)寄存器）
• 指針可以是 volatile

assert()

斷言，是宏，而非函數(shù)。assert 宏的原型定義在 （C）、（C++）中，其作用是如果它的條件返回錯誤，則終止程序執(zhí)行?？梢酝ㄟ^定義 NDEBUG 來關(guān)閉 assert，但是需要在源代碼的開頭，include 之前。

assert() 使用

#define NDEBUG     // 加上這行，則 assert 不可用
#include 

assert( p != NULL );  // assert 不可用

sizeof()

• sizeof 對數(shù)組，得到整個數(shù)組所占空間大小。
• sizeof 對指針，得到指針本身所占空間大小。

#pragma pack(n)

設(shè)定結(jié)構(gòu)體、聯(lián)合以及類成員變量以 n 字節(jié)方式對齊

#pragma pack(n) 使用

#pragma pack(push) // 保存對齊狀態(tài)
#pragma pack(4)   // 設(shè)定為 4 字節(jié)對齊

struct test
{
  char m1;
  double m4;
  int m3;
};

#pragma pack(pop)  // 恢復(fù)對齊狀態(tài)

位域

Bit mode: 2; // mode 占 2 位

類可以將其（非靜態(tài)）數(shù)據(jù)成員定義為位域（bit-field），在一個位域中含有一定數(shù)量的二進制位。當一個程序需要向其他程序或硬件設(shè)備傳遞二進制數(shù)據(jù)時，通常會用到位域。

• 位域在內(nèi)存中的布局是與機器有關(guān)的
• 位域的類型必須是整型或枚舉類型，帶符號類型中的位域的行為將因具體實現(xiàn)而定
• 取地址運算符（&）不能作用于位域，任何指針都無法指向類的位域

extern "C"

• 被 extern 限定的函數(shù)或變量是 extern 類型的
• 被 extern "C" 修飾的變量和函數(shù)是按照 C 語言方式編譯和鏈接的

extern "C" 的作用是讓 C++ 編譯器將 extern "C" 聲明的代碼當作 C 語言代碼處理，可以避免 C++ 因符號修飾導(dǎo)致代碼不能和C語言庫中的符號進行鏈接的問題。

extern "C" 使用

#ifdef __cplusplus
extern "C" {
#endif

void *memset(void *, int, size_t);

#ifdef __cplusplus
}
#endif

struct 和 typedef struct

C 中

// c
typedef struct Student {
  int age;
} S;

等價于

// c
struct Student {
  int age;
};

typedef struct Student S; 此時 S 等價于 struct Student，但兩個標識符名稱空間不相同。

另外還可以定義與 struct Student 不沖突的 void Student() {}。

C++ 中

由于編譯器定位符號的規(guī)則（搜索規(guī)則）改變，導(dǎo)致不同于C語言。

1.如果在類標識符空間定義了 struct Student {...};，使用 Student me; 時，編譯器將搜索全局標識符表，Student 未找到，則在類標識符內(nèi)搜索。

即表現(xiàn)為可以使用 Student 也可以使用 struct Student，如下：

// cpp
struct Student {
  int age;
};

void f( Student me );    // 正確，"struct" 關(guān)鍵字可省略

2.若定義了與 Student 同名函數(shù)之后，則 Student 只代表函數(shù)，不代表結(jié)構(gòu)體，如下：

typedef struct Student {
  int age;
} S;

void Student() {}      // 正確，定義后 "Student" 只代表此函數(shù)

//void S() {}        // 錯誤，符號 "S" 已經(jīng)被定義為一個 "struct Student" 的別名

int main() {
  Student();
  struct Student me;   // 或者 "S me";
  return 0;
}

C++ 中 struct 和 class

總的來說，struct 更適合看成是一個數(shù)據(jù)結(jié)構(gòu)的實現(xiàn)體，class 更適合看成是一個對象的實現(xiàn)體。

區(qū)別:

最本質(zhì)的一個區(qū)別就是默認的訪問控制

• 默認的繼承訪問權(quán)限。struct 是 public 的，class 是 private 的。
• struct 作為數(shù)據(jù)結(jié)構(gòu)的實現(xiàn)體，它默認的數(shù)據(jù)訪問控制是 public 的，而 class 作為對象的實現(xiàn)體，它默認的成員變量訪問控制是 private 的。

union 聯(lián)合

聯(lián)合（union）是一種節(jié)省空間的特殊的類，一個 union 可以有多個數(shù)據(jù)成員，但是在任意時刻只有一個數(shù)據(jù)成員可以有值。當某個成員被賦值后其他成員變?yōu)槲炊x狀態(tài)。聯(lián)合有如下特點：

• 默認訪問控制符為 public
• 可以含有構(gòu)造函數(shù)、析構(gòu)函數(shù)
• 不能含有引用類型的成員
• 不能繼承自其他類，不能作為基類
• 不能含有虛函數(shù)
• 匿名 union 在定義所在作用域可直接訪問 union 成員
• 匿名 union 不能包含 protected 成員或 private 成員
• 全局匿名聯(lián)合必須是靜態(tài)（static）的

union 使用

#include

union UnionTest {
  UnionTest() : i(10) {};
  int i;
  double d;
};

static union {
  int i;
  double d;
};

int main() {
  UnionTest u;

  union {
    int i;
    double d;
  };

  std::cout << u.i << std::endl; ?// 輸出 UnionTest 聯(lián)合的 10

 ? ?::i = 20;
 ? ?std::cout << ::i << std::endl; ?// 輸出全局靜態(tài)匿名聯(lián)合的 20

 ? ?i = 30;
 ? ?std::cout << i << std::endl; ? ?// 輸出局部匿名聯(lián)合的 30

 ? ?return 0;
}

C語言實現(xiàn)C++類

C 實現(xiàn) C++ 的面向?qū)ο筇匦裕ǚ庋b、繼承、多態(tài)）

• 封裝：使用函數(shù)指針把屬性與方法封裝到結(jié)構(gòu)體中
• 繼承：結(jié)構(gòu)體嵌套
• 多態(tài)：父類與子類方法的函數(shù)指針不同

explicit（顯式）關(guān)鍵字

• explicit 修飾構(gòu)造函數(shù)時，可以防止隱式轉(zhuǎn)換和復(fù)制初始化
• explicit 修飾轉(zhuǎn)換函數(shù)時，可以防止隱式轉(zhuǎn)換，但 按語境轉(zhuǎn)換 除外

explicit 使用

struct A
{
A(int) { }
operator bool() const { return true; }
};

struct B
{
explicit B(int) {}
explicit operator bool() const { return true; }
};

void doA(A a) {}

void doB(B b) {}

int main()
{
A a1(1);// OK：直接初始化
A a2 = 1;// OK：復(fù)制初始化
A a3{ 1 };// OK：直接列表初始化
A a4 = { 1 };// OK：復(fù)制列表初始化
A a5 = (A)1;// OK：允許 static_cast 的顯式轉(zhuǎn)換
doA(1);// OK：允許從 int 到 A 的隱式轉(zhuǎn)換
if (a1);// OK：使用轉(zhuǎn)換函數(shù) A::operator bool() 的從 A 到 bool 的隱式轉(zhuǎn)換
bool a6（a1）;// OK：使用轉(zhuǎn)換函數(shù) A::operator bool() 的從 A 到 bool 的隱式轉(zhuǎn)換
bool a7 = a1;// OK：使用轉(zhuǎn)換函數(shù) A::operator bool() 的從 A 到 bool 的隱式轉(zhuǎn)換
bool a8 = static_cast(a1); // OK ：static_cast 進行直接初始化

B b1(1);// OK：直接初始化
B b2 = 1;// 錯誤：被 explicit 修飾構(gòu)造函數(shù)的對象不可以復(fù)制初始化
B b3{ 1 };// OK：直接列表初始化
B b4 = { 1 };// 錯誤：被 explicit 修飾構(gòu)造函數(shù)的對象不可以復(fù)制列表初始化
B b5 = (B)1;// OK：允許 static_cast 的顯式轉(zhuǎn)換
doB(1);// 錯誤：被 explicit 修飾構(gòu)造函數(shù)的對象不可以從 int 到 B 的隱式轉(zhuǎn)換
if (b1);// OK：被 explicit 修飾轉(zhuǎn)換函數(shù) B::operator bool() 的對象可以從 B 到 bool 的按語境轉(zhuǎn)換
bool b6(b1);// OK：被 explicit 修飾轉(zhuǎn)換函數(shù) B::operator bool() 的對象可以從 B 到 bool 的按語境轉(zhuǎn)換
bool b7 = b1;// 錯誤：被 explicit 修飾轉(zhuǎn)換函數(shù) B::operator bool() 的對象不可以隱式轉(zhuǎn)換
bool b8 = static_cast(b1); // OK：static_cast 進行直接初始化

return 0;
}

friend 友元類和友元函數(shù)

• 能訪問私有成員
• 破壞封裝性
• 友元關(guān)系不可傳遞
• 友元關(guān)系的單向性
• 友元聲明的形式及數(shù)量不受限制

using

using 聲明

一條 using 聲明 語句一次只引入命名空間的一個成員。它使得我們可以清楚知道程序中所引用的到底是哪個名字。如：

using namespace_name::name;

構(gòu)造函數(shù)的 using 聲明

在 C++11 中，派生類能夠重用其直接基類定義的構(gòu)造函數(shù)。

class Derived : Base {
public:
  using Base::Base;
  /* ... */
};

如上 using 聲明，對于基類的每個構(gòu)造函數(shù)，編譯器都生成一個與之對應(yīng)（形參列表完全相同）的派生類構(gòu)造函數(shù)。生成如下類型構(gòu)造函數(shù)：Derived(parms) : Base(args) { }

using 指示

using 指示 使得某個特定命名空間中所有名字都可見，這樣我們就無需再為它們添加任何前綴限定符了。如：

using namespace_name name;

盡量少使用 using 指示 污染命名空間

一般說來，使用 using 命令比使用 using 編譯命令更安全，這是由于它只導(dǎo)入了指定的名稱。如果該名稱與局部名稱發(fā)生沖突，編譯器將發(fā)出指示。using編譯命令導(dǎo)入所有的名稱，包括可能并不需要的名稱。如果與局部名稱發(fā)生沖突，則局部名稱將覆蓋名稱空間版本，而編譯器并不會發(fā)出警告。另外，名稱空間的開放性意味著名稱空間的名稱可能分散在多個地方，這使得難以準確知道添加了哪些名稱。

using 使用

盡量少使用 using 指示

using namespace std;

應(yīng)該多使用 using 聲明

int x;
std::cin >> x ;
std::cout << x << std::endl;

或者

using std::cin;
using std::cout;
using std::endl;
int x;
cin >> x;
cout << x << endl;

:: 范圍解析運算符

分類

1. 全局作用域符（::name）：用于類型名稱（類、類成員、成員函數(shù)、變量等）前，表示作用域為全局命名空間
2. 類作用域符（class::name）：用于表示指定類型的作用域范圍是具體某個類的
3. 命名空間作用域符（namespace::name）:用于表示指定類型的作用域范圍是具體某個命名空間的

:: 使用

int count = 11;     // 全局（::）的 count

class A {
public:
static int count;  // 類 A 的 count（A::count）
};
int A::count = 21;

void fun()
{
int count = 31;   // 初始化局部的 count 為 31
count = 32;     // 設(shè)置局部的 count 的值為 32
}

int main() {
::count = 12;    // 測試 1：設(shè)置全局的 count 的值為 12

A::count = 22;   // 測試 2：設(shè)置類 A 的 count 為 22

fun();    // 測試 3

return 0;
}

enum 枚舉類型

定作用域的枚舉類型

enum class open_modes { input, output, append };

不限定作用域的枚舉類型

enum color { red, yellow, green };
 
enum { floatPrec = 6, doublePrec = 10 };

decltype

decltype 關(guān)鍵字用于檢查實體的聲明類型或表達式的類型及值分類。語法：

decltype ( expression )

decltype 使用

// 尾置返回允許我們在參數(shù)列表之后聲明返回類型
template 
auto fcn(It beg, It end) -> decltype(*beg)
{
  // 處理序列
  return *beg;  // 返回序列中一個元素的引用
}
// 為了使用模板參數(shù)成員，必須用 typename
template 
auto fcn2(It beg, It end) -> typename remove_reference::type
{
  // 處理序列
  return *beg;  // 返回序列中一個元素的拷貝
}

引用

左值引用

常規(guī)引用，一般表示對象的身份。

右值引用

右值引用就是必須綁定到右值（一個臨時對象、將要銷毀的對象）的引用，一般表示對象的值。

右值引用可實現(xiàn)轉(zhuǎn)移語義（Move Sementics）和精確傳遞（Perfect Forwarding），它的主要目的有兩個方面：

• 消除兩個對象交互時不必要的對象拷貝，節(jié)省運算存儲資源，提高效率。
• 能夠更簡潔明確地定義泛型函數(shù)。

引用折疊

• X& &、X& &&、X&& & 可折疊成 X&
• X&& && 可折疊成 X&&

宏

宏定義可以實現(xiàn)類似于函數(shù)的功能，但是它終歸不是函數(shù)，而宏定義中括弧中的“參數(shù)”也不是真的參數(shù)，在宏展開的時候?qū)?“參數(shù)” 進行的是一對一的替換。

成員初始化列表

好處

1. 更高效：少了一次調(diào)用默認構(gòu)造函數(shù)的過程。
2. 有些場合必須要用初始化列表：

• 常量成員，因為常量只能初始化不能賦值，所以必須放在初始化列表里面
• 引用類型，引用必須在定義的時候初始化，并且不能重新賦值，所以也要寫在初始化列表里面
• 沒有默認構(gòu)造函數(shù)的類類型，因為使用初始化列表可以不必調(diào)用默認構(gòu)造函數(shù)來初始化

initializer_list 列表初始化

用花括號初始化器列表初始化一個對象，其中對應(yīng)構(gòu)造函數(shù)接受一個 std::initializer_list 參數(shù).

initializer_list 使用

#include 
#include 
#include 
 
template 
struct S {
  std::vector v;
  S(std::initializer_list l) : v(l) {
     std::cout << "constructed with a " << l.size() << "-element list
";
 ? ?}
 ? ?void append(std::initializer_list l) {
    v.insert(v.end(), l.begin(), l.end());
  }
  std::pair c_arr() const {
    return {&v[0], v.size()}; // 在 return 語句中復(fù)制列表初始化
                  // 這不使用 std::initializer_list
  }
};
 
template 
void templated_fn(T) {}
 
int main()
{
  S s = {1, 2, 3, 4, 5}; // 復(fù)制初始化
  s.append({6, 7, 8});   // 函數(shù)調(diào)用中的列表初始化
 
  std::cout << "The vector size is now " << s.c_arr().second << " ints:
";
 
 ? ?for (auto n : s.v)
 ? ? ? ?std::cout << n << ' ';
 ? ?std::cout << '
';
 
 ? ?std::cout << "Range-for over brace-init-list: 
";
 
 ? ?for (int x : {-1, -2, -3}) // auto 的規(guī)則令此帶范圍 for 工作
 ? ? ? ?std::cout << x << ' ';
 ? ?std::cout << '
';
 
 ? ?auto al = {10, 11, 12}; ? // auto 的特殊規(guī)則
 
 ? ?std::cout << "The list bound to auto has size() = " << al.size() << '
';
 
// ?  templated_fn({1, 2, 3}); // 編譯錯誤！“ {1, 2, 3} ”不是表達式，
 ? ? ? ? ? ? ? ? ? ? ? ? ? ? // 它無類型，故 T 無法推導(dǎo)
 ? ?templated_fn>({1, 2, 3}); // OK
  templated_fn>({1, 2, 3});      // 也 OK
}

面向?qū)ο?/span>

面向?qū)ο蟪绦蛟O(shè)計（Object-oriented programming，OOP）是種具有對象概念的程序編程典范，同時也是一種程序開發(fā)的抽象方針。

面向?qū)ο筇卣?/p>

面向?qū)ο笕筇卣?—— 封裝、繼承、多態(tài)

封裝

把客觀事物封裝成抽象的類，并且類可以把自己的數(shù)據(jù)和方法只讓可信的類或者對象操作，對不可信的進行信息隱藏。關(guān)鍵字：public, protected, private。不寫默認為 private。

• public 成員：可以被任意實體訪問
• protected 成員：只允許被子類及本類的成員函數(shù)訪問
• private 成員：只允許被本類的成員函數(shù)、友元類或友元函數(shù)訪問

繼承

• 基類（父類）——> 派生類（子類）

多態(tài)

1. 多態(tài)，即多種狀態(tài)（形態(tài)）。簡單來說，我們可以將多態(tài)定義為消息以多種形式顯示的能力。
2. 多態(tài)是以封裝和繼承為基礎(chǔ)的。
3. C++ 多態(tài)分類及實現(xiàn)：

• 重載多態(tài)（Ad-hoc Polymorphism，編譯期）：函數(shù)重載、運算符重載
• 子類型多態(tài)（Subtype Polymorphism，運行期）：虛函數(shù)
• 參數(shù)多態(tài)性（Parametric Polymorphism，編譯期）：類模板、函數(shù)模板
• 強制多態(tài)（Coercion Polymorphism，編譯期/運行期）：基本類型轉(zhuǎn)換、自定義類型轉(zhuǎn)換

靜態(tài)多態(tài)（編譯期/早綁定）

函數(shù)重載

class A
{
public:
  void do(int a);
  void do(int a, int b);
};

動態(tài)多態(tài)（運行期期/晚綁定）

• 虛函數(shù)：用 virtual 修飾成員函數(shù)，使其成為虛函數(shù)

注意：

• 普通函數(shù)（非類成員函數(shù)）不能是虛函數(shù)
• 靜態(tài)函數(shù)（static）不能是虛函數(shù)
• 構(gòu)造函數(shù)不能是虛函數(shù)（因為在調(diào)用構(gòu)造函數(shù)時，虛表指針并沒有在對象的內(nèi)存空間中，必須要構(gòu)造函數(shù)調(diào)用完成后才會形成虛表指針）
• 內(nèi)聯(lián)函數(shù)不能是表現(xiàn)多態(tài)性時的虛函數(shù)，解釋見：虛函數(shù)（virtual）可以是內(nèi)聯(lián)函數(shù)（inline）嗎？

動態(tài)多態(tài)使用

class Shape           // 形狀類
{
public:
  virtual double calcArea()
  {
    ...
  }
  virtual ~Shape();
};
class Circle : public Shape   // 圓形類
{
public:
  virtual double calcArea();
  ...
};
class Rect : public Shape    // 矩形類
{
public:
  virtual double calcArea();
  ...
};
int main()
{
  Shape * shape1 = new Circle(4.0);
  Shape * shape2 = new Rect(5.0, 6.0);
  shape1->calcArea();     // 調(diào)用圓形類里面的方法
  shape2->calcArea();     // 調(diào)用矩形類里面的方法
  delete shape1;
  shape1 = nullptr;
  delete shape2;
  shape2 = nullptr;
  return 0;
}

虛析構(gòu)函數(shù)

虛析構(gòu)函數(shù)是為了解決基類的指針指向派生類對象，并用基類的指針刪除派生類對象。

虛析構(gòu)函數(shù)使用

class Shape
{
public:
  Shape();          // 構(gòu)造函數(shù)不能是虛函數(shù)
  virtual double calcArea();
  virtual ~Shape();      // 虛析構(gòu)函數(shù)
};
class Circle : public Shape   // 圓形類
{
public:
  virtual double calcArea();
  ...
};
int main()
{
  Shape * shape1 = new Circle(4.0);
  shape1->calcArea();
   delete shape1; // 因為Shape有虛析構(gòu)函數(shù)，所以delete釋放內(nèi)存時，先調(diào)用子類析構(gòu)函數(shù)，再調(diào)用基類析構(gòu)函數(shù)，防止內(nèi)存泄漏。
  shape1 = NULL;
   return 0；
}

純虛函數(shù)

純虛函數(shù)是一種特殊的虛函數(shù)，在基類中不能對虛函數(shù)給出有意義的實現(xiàn)，而把它聲明為純虛函數(shù)，它的實現(xiàn)留給該基類的派生類去做。

virtual int A() = 0;

虛函數(shù)、純虛函數(shù)

• 類里如果聲明了虛函數(shù)，這個函數(shù)是實現(xiàn)的，哪怕是空實現(xiàn)，它的作用就是為了能讓這個函數(shù)在它的子類里面可以被覆蓋（override），這樣的話，編譯器就可以使用后期綁定來達到多態(tài)了。純虛函數(shù)只是一個接口，是個函數(shù)的聲明而已，它要留到子類里去實現(xiàn)。
• 虛函數(shù)在子類里面可以不重寫；但純虛函數(shù)必須在子類實現(xiàn)才可以實例化子類。虛函數(shù)的類用于 “實作繼承”，繼承接口的同時也繼承了父類的實現(xiàn)。
• 純虛函數(shù)關(guān)注的是接口的統(tǒng)一性，實現(xiàn)由子類完成。
• 帶純虛函數(shù)的類叫抽象類，這種類不能直接生成對象，而只有被繼承，并重寫其虛函數(shù)后，才能使用。抽象類被繼承后，子類可以繼續(xù)是抽象類，也可以是普通類。
• 虛基類是虛繼承中的基類，具體見下文虛繼承。

虛函數(shù)指針、虛函數(shù)表

• 虛函數(shù)指針：在含有虛函數(shù)類的對象中，指向虛函數(shù)表，在運行時確定。
• 虛函數(shù)表：在程序只讀數(shù)據(jù)段（.rodata section，見：目標文件存儲結(jié)構(gòu)），存放虛函數(shù)指針，如果派生類實現(xiàn)了基類的某個虛函數(shù)，則在虛表中覆蓋原本基類的那個虛函數(shù)指針，在編譯時根據(jù)類的聲明創(chuàng)建。

虛繼承

虛繼承用于解決多繼承條件下的菱形繼承問題（浪費存儲空間、存在二義性）。

底層實現(xiàn)原理與編譯器相關(guān)，一般通過虛基類指針和虛基類表實現(xiàn)，每個虛繼承的子類都有一個虛基類指針（占用一個指針的存儲空間，4字節(jié)）和虛基類表（不占用類對象的存儲空間）（需要強調(diào)的是，虛基類依舊會在子類里面存在拷貝，只是僅僅最多存在一份而已，并不是不在子類里面了）；當虛繼承的子類被當做父類繼承時，虛基類指針也會被繼承。

實際上，vbptr 指的是虛基類表指針（virtual base table pointer），該指針指向了一個虛基類表（virtual table），虛表中記錄了虛基類與本類的偏移地址；通過偏移地址，這樣就找到了虛基類成員，而虛繼承也不用像普通多繼承那樣維持著公共基類（虛基類）的兩份同樣的拷貝，節(jié)省了存儲空間。

虛繼承、虛函數(shù)

1. 相同之處：都利用了虛指針（均占用類的存儲空間）和虛表（均不占用類的存儲空間）
2. 不同之處：

虛繼承

• 虛基類依舊存在繼承類中，只占用存儲空間
• 虛基類表存儲的是虛基類相對直接繼承類的偏移

虛函數(shù)

• 虛函數(shù)不占用存儲空間
• 虛函數(shù)表存儲的是虛函數(shù)地址

模板類、成員模板、虛函數(shù)

• 模板類中可以使用虛函數(shù)
• 一個類（無論是普通類還是類模板）的成員模板（本身是模板的成員函數(shù)）不能是虛函數(shù)

抽象類、接口類、聚合類

抽象類：含有純虛函數(shù)的類

接口類：僅含有純虛函數(shù)的抽象類

聚合類：用戶可以直接訪問其成員，并且具有特殊的初始化語法形式。滿足如下特點：

• 所有成員都是 public
• 沒有定義任何構(gòu)造函數(shù)
• 沒有類內(nèi)初始化
• 沒有基類，也沒有 virtual 函數(shù)

內(nèi)存分配和管理

malloc、calloc、realloc、alloca

---

1. malloc：申請指定字節(jié)數(shù)的內(nèi)存。申請到的內(nèi)存中的初始值不確定。
2. calloc：為指定長度的對象，分配能容納其指定個數(shù)的內(nèi)存。申請到的內(nèi)存的每一位（bit）都初始化為 0。
3. realloc：更改以前分配的內(nèi)存長度（增加或減少）。當增加長度時，可能需將以前分配區(qū)的內(nèi)容移到另一個足夠大的區(qū)域，而新增區(qū)域內(nèi)的初始值則不確定。
4. alloca：在棧上申請內(nèi)存。程序在出棧的時候，會自動釋放內(nèi)存。但是需要注意的是，alloca 不具可移植性, 而且在沒有傳統(tǒng)堆棧的機器上很難實現(xiàn)。alloca 不宜使用在必須廣泛移植的程序中。C99 中支持變長數(shù)組 (VLA)，可以用來替代 alloca。

malloc、free

用于分配、釋放內(nèi)存

malloc、free 使用

申請內(nèi)存，確認是否申請成功

char *str = (char*) malloc(100);
assert(str != nullptr);

釋放內(nèi)存后指針置空

free(p);
p = nullptr;

new、delete

1. new / new[]：完成兩件事，先底層調(diào)用 malloc 分配了內(nèi)存，然后調(diào)用構(gòu)造函數(shù)（創(chuàng)建對象）。
2. delete/delete[]：也完成兩件事，先調(diào)用析構(gòu)函數(shù)（清理資源），然后底層調(diào)用 free 釋放空間。
3. new 在申請內(nèi)存時會自動計算所需字節(jié)數(shù)，而 malloc 則需我們自己輸入申請內(nèi)存空間的字節(jié)數(shù)。

new、delete 使用

申請內(nèi)存，確認是否申請成功

int main()
{
  T* t = new T();   // 先內(nèi)存分配 ，再構(gòu)造函數(shù)
  delete t;      // 先析構(gòu)函數(shù)，再內(nèi)存釋放
  return 0;
}

定位 new

定位 new（placement new）允許我們向 new 傳遞額外的地址參數(shù)，從而在預(yù)先指定的內(nèi)存區(qū)域創(chuàng)建對象。

new (place_address) type
new (place_address) type (initializers)
new (place_address) type [size]
new (place_address) type [size] { braced initializer list }

• place_address 是個指針
• initializers 提供一個（可能為空的）以逗號分隔的初始值列表

delete this 合法嗎？

合法，但：

• 必須保證 this 對象是通過 new（不是 new[]、不是 placement new、不是棧上、不是全局、不是其他對象成員）分配的
• 必須保證調(diào)用 delete this 的成員函數(shù)是最后一個調(diào)用 this 的成員函數(shù)
• 必須保證成員函數(shù)的 delete this 后面沒有調(diào)用 this 了
• 必須保證 delete this 后沒有人使用了

定義只在堆(棧)生成對象類

只能在堆上

方法：將析構(gòu)函數(shù)設(shè)置為私有

原因：C++ 是靜態(tài)綁定語言，編譯器管理棧上對象的生命周期，編譯器在為類對象分配棧空間時，會先檢查類的析構(gòu)函數(shù)的訪問性。若析構(gòu)函數(shù)不可訪問，則不能在棧上創(chuàng)建對象。

能在棧上

方法：將 new 和 delete 重載為私有

原因：在堆上生成對象，使用 new 關(guān)鍵詞操作，其過程分為兩階段：第一階段，使用 new 在堆上尋找可用內(nèi)存，分配給對象；第二階段，調(diào)用構(gòu)造函數(shù)生成對象。將 new 操作設(shè)置為私有，那么第一階段就無法完成，就不能夠在堆上生成對象。

智能指針

C++ 標準庫（STL）中

頭文件：#include

C++ 98

std::auto_ptr ps (new std::string(str))；

C++ 11

對于該論述，歡迎讀者查閱之前發(fā)過的文章，你是《未來世界的幸存者》么？

3.7 分割線

可以在一行中用三個以上的減號來建立一個分隔線，同時需要在分隔線的上面空一行。如下：

1. shared_ptr
2. unique_ptr
3. weak_ptr
4. auto_ptr（被 C++11 棄用）

• Class shared_ptr 實現(xiàn)共享式擁有（shared ownership）概念。多個智能指針指向相同對象，該對象和其相關(guān)資源會在 “最后一個 reference 被銷毀” 時被釋放。為了在結(jié)構(gòu)較復(fù)雜的情景中執(zhí)行上述工作，標準庫提供 weak_ptr、bad_weak_ptr 和 enable_shared_from_this 等輔助類。
• Class unique_ptr 實現(xiàn)獨占式擁有（exclusive ownership）或嚴格擁有（strict ownership）概念，保證同一時間內(nèi)只有一個智能指針可以指向該對象。你可以移交擁有權(quán)。它對于避免內(nèi)存泄漏（resource leak）——如 new 后忘記 delete ——特別有用。

shared_ptr

多個智能指針可以共享同一個對象，對象的最末一個擁有著有責任銷毀對象，并清理與該對象相關(guān)的所有資源。

• 支持定制型刪除器（custom deleter），可防范 Cross-DLL 問題（對象在動態(tài)鏈接庫（DLL）中被 new 創(chuàng)建，卻在另一個 DLL 內(nèi)被 delete 銷毀）、自動解除互斥鎖

weak_ptr

weak_ptr 允許你共享但不擁有某對象，一旦最末一個擁有該對象的智能指針失去了所有權(quán)，任何 weak_ptr 都會自動成空（empty）。因此，在 default 和 copy 構(gòu)造函數(shù)之外，weak_ptr 只提供 “接受一個 shared_ptr” 的構(gòu)造函數(shù)。

• 可打破環(huán)狀引用（cycles of references，兩個其實已經(jīng)沒有被使用的對象彼此互指，使之看似還在 “被使用” 的狀態(tài)）的問題

unique_ptr

unique_ptr 是 C++11 才開始提供的類型，是一種在異常時可以幫助避免資源泄漏的智能指針。采用獨占式擁有，意味著可以確保一個對象和其相應(yīng)的資源同一時間只被一個 pointer 擁有。一旦擁有著被銷毀或編程 empty，或開始擁有另一個對象，先前擁有的那個對象就會被銷毀，其任何相應(yīng)資源亦會被釋放。

• unique_ptr 用于取代 auto_ptr

auto_ptr

被 c++11 棄用，原因是缺乏語言特性如 “針對構(gòu)造和賦值” 的 std::move 語義，以及其他瑕疵。

auto_ptr 與 unique_ptr 比較

• auto_ptr 可以賦值拷貝，復(fù)制拷貝后所有權(quán)轉(zhuǎn)移；unqiue_ptr 無拷貝賦值語義，但實現(xiàn)了move 語義；
• auto_ptr 對象不能管理數(shù)組（析構(gòu)調(diào)用 delete），unique_ptr 可以管理數(shù)組（析構(gòu)調(diào)用 delete[] ）；

強制類型轉(zhuǎn)換運算符

static_cast

• 用于非多態(tài)類型的轉(zhuǎn)換
• 不執(zhí)行運行時類型檢查（轉(zhuǎn)換安全性不如 dynamic_cast）
• 通常用于轉(zhuǎn)換數(shù)值數(shù)據(jù)類型（如 float -> int）
• 可以在整個類層次結(jié)構(gòu)中移動指針，子類轉(zhuǎn)化為父類安全（向上轉(zhuǎn)換），父類轉(zhuǎn)化為子類不安全（因為子類可能有不在父類的字段或方法）

dynamic_cast

• 用于多態(tài)類型的轉(zhuǎn)換
• 執(zhí)行行運行時類型檢查
• 只適用于指針或引用
• 對不明確的指針的轉(zhuǎn)換將失?。ǚ祷?nullptr），但不引發(fā)異常
• 可以在整個類層次結(jié)構(gòu)中移動指針，包括向上轉(zhuǎn)換、向下轉(zhuǎn)換

const_cast

• 用于刪除 const、volatile 和 __unaligned 特性（如將 const int 類型轉(zhuǎn)換為 int 類型 ）

reinterpret_cast

• 用于位的簡單重新解釋
• 濫用 reinterpret_cast 運算符可能很容易帶來風險。除非所需轉(zhuǎn)換本身是低級別的，否則應(yīng)使用其他強制轉(zhuǎn)換運算符之一。
• 允許將任何指針轉(zhuǎn)換為任何其他指針類型（如 char* 到 int* 或 One_class* 到 Unrelated_class* 之類的轉(zhuǎn)換，但其本身并不安全）
• 也允許將任何整數(shù)類型轉(zhuǎn)換為任何指針類型以及反向轉(zhuǎn)換。
• reinterpret_cast 運算符不能丟掉 const、volatile 或 __unaligned 特性。
• reinterpret_cast 的一個實際用途是在哈希函數(shù)中，即，通過讓兩個不同的值幾乎不以相同的索引結(jié)尾的方式將值映射到索引。

bad_cast

• 由于強制轉(zhuǎn)換為引用類型失敗，dynamic_cast 運算符引發(fā) bad_cast 異常。

bad_cast 使用

try {
  Circle& ref_circle = dynamic_cast(ref_shape);
}
catch (bad_cast b) {
  cout << "Caught: " << b.what();
}

運行時類型信息 (RTTI)

dynamic_cast

• 用于多態(tài)類型的轉(zhuǎn)換

typeid

• typeid 運算符允許在運行時確定對象的類型
• type_id 返回一個 type_info 對象的引用
• 如果想通過基類的指針獲得派生類的數(shù)據(jù)類型，基類必須帶有虛函數(shù)
• 只能獲取對象的實際類型

type_info

• type_info 類描述編譯器在程序中生成的類型信息。此類的對象可以有效存儲指向類型的名稱的指針。type_info 類還可存儲適合比較兩個類型是否相等或比較其排列順序的編碼值。類型的編碼規(guī)則和排列順序是未指定的，并且可能因程序而異。
• 頭文件：typeinfo

typeid、type_info 使用

#include 
using namespace std;

class Flyable            // 能飛的
{
public:
  virtual void takeoff() = 0;   // 起飛
  virtual void land() = 0;    // 降落
};
class Bird : public Flyable     // 鳥
{
public:
  void foraging() {...}      // 覓食
  virtual void takeoff() {...}
  virtual void land() {...}
  virtual ~Bird(){}
};
class Plane : public Flyable    // 飛機
{
public:
  void carry() {...}       // 運輸
  virtual void takeoff() {...}
  virtual void land() {...}
};

class type_info
{
public:
  const char* name() const;
  bool operator == (const type_info & rhs) const;
  bool operator != (const type_info & rhs) const;
  int before(const type_info & rhs) const;
  virtual ~type_info();
private:
  ...
};

void doSomething(Flyable *obj)         // 做些事情
{
  obj->takeoff();

  cout << typeid(*obj).name() << endl; ? ? ? ?// 輸出傳入對象類型（"class Bird" or "class Plane"）

 ? ?if(typeid(*obj) == typeid(Bird)) ? ? ? ? ? ?// 判斷對象類型
 ? ?{
 ? ? ? ?Bird *bird = dynamic_cast(obj); // 對象轉(zhuǎn)化
    bird->foraging();
  }

  obj->land();
}

int main(){
Bird *b = new Bird();
doSomething(b);
delete b;
b = nullptr;
return 0;
}