五萬字長文 C C++ 面試知識總結（上）

列文發表於2019-04-24

C++面試

C/C++ 面試知識總結

這是一篇五萬字的C/C++面試知識點總結，包括答案：這是上篇，下篇今天也推送了，需要的同學記得去看看。本文花費了博主大量的時間進行收集、排版：如果你覺得文章對你有幫助，幫忙點贊給博主一點鼓勵~~

C/C++
STL
資料結構
演算法
Problems
作業系統
計算機網路
網路程式設計
資料庫
設計模式
連結裝載庫
海量資料處理
音視訊
其他
書籍
複習刷題網站
招聘時間崗位
面試題目經驗

C/C++

const

作用

修飾變數，說明該變數不可以被改變；
修飾指標，分為指向常量的指標和指標常量；
常量引用，經常用於形參型別，即避免了拷貝，又避免了函式對值的修改；
修飾成員函式，說明該成員函式內不能修改成員變數。

使用

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

public:
    // 建構函式
    A() { };
    A(int x) : a(x) { };        // 初始化列表

    // const可用於對過載函式的區分
    int getValue();             // 普通成員函式
    int getValue() const;       // 常成員函式，不得修改類中的任何資料成員的值
};

void function()
{
    // 物件
    A b;                        // 普通物件，可以呼叫全部成員函式
    const A a;                  // 常物件，只能呼叫常成員函式、更新常成員變數
    const A *p = &a;            // 常指標
    const A &q = a;             // 常引用

    // 指標
    char greeting[] = "Hello";
    char* p1 = greeting;                // 指標變數，指向字元陣列變數
    const char* p2 = greeting;          // 指標變數，指向字元陣列常量
    char* const p3 = greeting;          // 常指標，指向字元陣列變數
    const char* const p4 = greeting;    // 常指標，指向字元陣列常量
}

// 函式
void function1(const int Var);           // 傳遞過來的引數在函式內不可變
void function2(const char* Var);         // 引數指標所指內容為常量
void function3(char* const Var);         // 引數指標為常指標
void function4(const int& Var);          // 引用引數在函式內為常量

// 函式返回值
const int function5();      // 返回一個常數
const int* function6();     // 返回一個指向常量的指標變數，使用：const int *p = function6();
int* const function7();     // 返回一個指向變數的常指標，使用：int* const p = function7();
複製程式碼

static

作用

修飾普通變數，修改變數的儲存區域和生命週期，使變數儲存在靜態區，在 main 函式執行前就分配了空間，如果有初始值就用初始值初始化它，如果沒有初始值系統用預設值初始化它。
修飾普通函式，表明函式的作用範圍，僅在定義該函式的檔案內才能使用。在多人開發專案時，為了防止與他人命令函式重名，可以將函式定位為 static。
修飾成員變數，修飾成員變數使所有的物件只儲存一個該變數，而且不需要生成物件就可以訪問該成員。
修飾成員函式，修飾成員函式使得不需要生成物件就可以訪問該函式，但是在 static 函式內不能訪問非靜態成員。

this 指標

this 指標是一個隱含於每一個非靜態成員函式中的特殊指標。它指向正在被該成員函式操作的那個物件。
當對一個物件呼叫成員函式時，編譯程式先將物件的地址賦給 this 指標，然後呼叫成員函式，每次成員函式存取資料成員時，由隱含使用 this 指標。
當一個成員函式被呼叫時，自動向它傳遞一個隱含的引數，該引數是一個指向這個成員函式所在的物件的指標。
this 指標被隱含地宣告為: ClassName *const this，這意味著不能給 this 指標賦值；在 ClassName 類的 const 成員函式中，this 指標的型別為：const ClassName* const，這說明不能對 this 指標所指向的這種物件是不可修改的（即不能對這種物件的資料成員進行賦值操作）；
this 並不是一個常規變數，而是個右值，所以不能取得 this 的地址（不能 &this）。
在以下場景中，經常需要顯式引用 this 指標：
為實現物件的鏈式引用；
為避免對同一物件進行賦值操作；
在實現一些資料結構時，如 list。

inline 行內函數

特徵

相當於把行內函數裡面的內容寫在呼叫行內函數處；
相當於不用執行進入函式的步驟，直接執行函式體；
相當於巨集，卻比巨集多了型別檢查，真正具有函式特性；
不能包含迴圈、遞迴、switch 等複雜操作；
在類宣告中定義的函式，除了虛擬函式的其他函式都會自動隱式地當成行內函數。

使用

// 宣告1（加 inline，建議使用）
inline int functionName(int first, int secend,...);

// 宣告2（不加 inline）
int functionName(int first, int secend,...);

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

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

// 類外定義，需要顯式內聯
class A {
    int doA();
}
inline int A::doA() { return 0; }   // 需要顯式內聯
複製程式碼

編譯器對 inline 函式的處理步驟

將 inline 函式體複製到 inline 函式呼叫點處；
為所用 inline 函式中的區域性變數分配記憶體空間；
將 inline 函式的的輸入引數和返回值對映到呼叫方法的區域性變數空間中；
如果 inline 函式有多個返回點，將其轉變為 inline 函式程式碼塊末尾的分支（使用 GOTO）。

優缺點

優點

行內函數同巨集函式一樣將在被呼叫處進行程式碼展開，省去了引數壓棧、棧幀開闢與回收，結果返回等，從而提高程式執行速度。
行內函數相比巨集函式來說，在程式碼展開時，會做安全檢查或自動型別轉換（同普通函式），而巨集定義則不會。
在類中宣告同時定義的成員函式，自動轉化為行內函數，因此行內函數可以訪問類的成員變數，巨集定義則不能。
行內函數在執行時可除錯，而巨集定義不可以。

缺點

程式碼膨脹。內聯是以程式碼膨脹（複製）為代價，消除函式呼叫帶來的開銷。如果執行函式體內程式碼的時間，相比於函式呼叫的開銷較大，那麼效率的收穫會很少。另一方面，每一處行內函數的呼叫都要複製程式碼，將使程式的總程式碼量增大，消耗更多的記憶體空間。
inline 函式無法隨著函式庫升級而升級。inline函式的改變需要重新編譯，不像 non-inline 可以直接連結。
是否內聯，程式設計師不可控。行內函數只是對編譯器的建議，是否對函式內聯，決定權在於編譯器。

虛擬函式（virtual）可以是行內函數（inline）嗎？

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

答案：www.cs.technion.ac.il/users/yechi…

虛擬函式可以是行內函數，內聯是可以修飾虛擬函式的，但是當虛擬函式表現多型性的時候不能內聯。
內聯是在編譯器建議編譯器內聯，而虛擬函式的多型性在執行期，編譯器無法知道執行期呼叫哪個程式碼，因此虛擬函式表現為多型性時（執行期）不可以內聯。
inline virtual 唯一可以內聯的時候是：編譯器知道所呼叫的物件是哪個類（如 Base::who()），這隻有在編譯器具有實際物件而不是物件的指標或引用時才會發生。

虛擬函式內聯使用

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

int main()
{
    // 此處的虛擬函式 who()，是通過類（Base）的具體物件（b）來呼叫的，編譯期間就能確定了，所以它可以是內聯的，但最終是否內聯取決於編譯器。 
    Base b;
    b.who();

    // 此處的虛擬函式是通過指標呼叫的，呈現多型性，需要在執行時期間才能確定，所以不能為內聯。  
    Base *ptr = new Derived();
    ptr->who();

    // 因為Base有虛解構函式（virtual ~Base() {}），所以 delete 時，會先呼叫派生類（Derived）解構函式，再呼叫基類（Base）解構函式，防止記憶體洩漏。
    delete ptr;
    ptr = nullptr;

    system("pause");
    return 0;
} 
複製程式碼

assert()

斷言，是巨集，而非函式。assert 巨集的原型定義在 <assert.h>（C）、<cassert>（C++）中，其作用是如果它的條件返回錯誤，則終止程式執行。可以通過定義 NDEBUG 來關閉 assert，但是需要在原始碼的開頭，include <assert.h> 之前。

使用

#define NDEBUG          // 加上這行，則 assert 不可用
#include <assert.h>

assert( p != NULL );    // assert 不可用
複製程式碼

sizeof()

sizeof 對陣列，得到整個陣列所佔空間大小。
sizeof 對指標，得到指標本身所佔空間大小。

#pragma pack(n)

設定結構體、聯合以及類成員變數以 n 位元組方式對齊

使用

#pragma pack(push)  // 儲存對齊狀態
#pragma pack(4)     // 設定為 4 位元組對齊

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

#pragma pack(pop)   // 恢復對齊狀態
複製程式碼

位域

Bit mode: 2;    // mode 佔 2 位
複製程式碼

類可以將其（非靜態）資料成員定義為位域（bit-field），在一個位域中含有一定數量的二進位制位。當一個程式需要向其他程式或硬體裝置傳遞二進位制資料時，通常會用到位域。

位域在記憶體中的佈局是與機器有關的
位域的型別必須是整型或列舉型別，帶符號型別中的位域的行為將因具體實現而定
取地址運算子（&）不能作用於位域，任何指標都無法指向類的位域

volatile

volatile int i = 10; 
複製程式碼

volatile 關鍵字是一種型別修飾符，用它宣告的型別變數表示可以被某些編譯器未知的因素（作業系統、硬體、其它執行緒等）更改。所以使用 volatile 告訴編譯器不應對這樣的物件進行優化。
volatile 關鍵字宣告的變數，每次訪問時都必須從記憶體中取出值（沒有被 volatile 修飾的變數，可能由於編譯器的優化，從 CPU 暫存器中取值）
const 可以是 volatile （如只讀的狀態暫存器）
指標可以是 volatile

extern "C"

被 extern 限定的函式或變數是 extern 型別的
被 extern "C" 修飾的變數和函式是按照 C 語言方式編譯和連線的

extern "C" 的作用是讓 C++ 編譯器將 extern "C" 宣告的程式碼當作 C 語言程式碼處理，可以避免 C++ 因符號修飾導致程式碼不能和C語言庫中的符號進行連結的問題。

"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++ 中

由於編譯器定位符號的規則（搜尋規則）改變，導致不同於C語言。

一、如果在類識別符號空間定義了 struct Student {...};，使用 Student me; 時，編譯器將搜尋全域性識別符號表，Student 未找到，則在類識別符號內搜尋。

即表現為可以使用 Student 也可以使用 struct Student，如下：

// cpp
struct Student { 
    int age; 
};

void f( Student me );       // 正確，"struct" 關鍵字可省略
複製程式碼

二、若定義了與 Student 同名函式之後，則 Student 只代表函式，不代表結構體，如下：

typedef struct Student { 
    int age; 
} S;

void Student() {}           // 正確，定義後 "Student" 只代表此函式

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

int main() {
    Student(); 
    struct Student me;      // 或者 "S me";
    return 0;
}
複製程式碼

C++ 中 struct 和 class

總的來說，struct 更適合看成是一個資料結構的實現體，class 更適合看成是一個物件的實現體。

區別

最本質的一個區別就是預設的訪問控制

預設的繼承訪問許可權。struct 是 public 的，class 是 private 的。
struct 作為資料結構的實現體，它預設的資料訪問控制是 public 的，而 class 作為物件的實現體，它預設的成員變數訪問控制是 private 的。

union 聯合

聯合（union）是一種節省空間的特殊的類，一個 union 可以有多個資料成員，但是在任意時刻只有一個資料成員可以有值。當某個成員被賦值後其他成員變為未定義狀態。聯合有如下特點：

預設訪問控制符為 public
可以含有建構函式、解構函式
不能含有引用型別的成員
不能繼承自其他類，不能作為基類
不能含有虛擬函式
匿名 union 在定義所在作用域可直接訪問 union 成員
匿名 union 不能包含 protected 成員或 private 成員
全域性匿名聯合必須是靜態（static）的

使用

#include<iostream>

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 聯合的 10

    ::i = 20;
    std::cout << ::i << std::endl;  // 輸出全域性靜態匿名聯合的 20

    i = 30;
    std::cout << i << std::endl;    // 輸出區域性匿名聯合的 30

    return 0;
}
複製程式碼

C 實現 C++ 類

C 語言實現封裝、繼承和多型：

dongxicheng.org/cpp/ooc/

explicit（顯式）建構函式

explicit 修飾的建構函式可用來防止隱式轉換

explicit 使用

class Test1
{
public:
    Test1(int n)            // 普通建構函式
    {
        num=n;
    }
private:
    int num;
};

class Test2
{
public:
    explicit Test2(int n)   // explicit（顯式）建構函式
    {
        num=n;
    }
private:
    int num;
};

int main()
{
    Test1 t1=12;            // 隱式呼叫其建構函式，成功
    Test2 t2=12;            // 編譯錯誤，不能隱式呼叫其建構函式
    Test2 t2(12);           // 顯式呼叫成功
    return 0;
}
複製程式碼

friend 友元類和友元函式

能訪問私有成員
破壞封裝性
友元關係不可傳遞
友元關係的單向性
友元宣告的形式及數量不受限制

using

using 宣告

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

using namespace_name::name;
複製程式碼

建構函式的 using 宣告【C++11】

在 C++11 中，派生類能夠重用其直接基類定義的建構函式。

class Derived : Base {
public:
    using Base::Base;
    /* ... */
};
複製程式碼

如上 using 宣告，對於基類的每個建構函式，編譯器都生成一個與之對應（形參列表完全相同）的派生類建構函式。生成如下型別建構函式：

derived(parms) : base(args) { }
複製程式碼

using 指示

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

using namespace_name name;
複製程式碼

儘量少使用 `using 指示` 汙染名稱空間

一般說來，使用 using 命令比使用 using 編譯命令更安全，這是由於它只匯入了制定的名稱。如果該名稱與區域性名稱發生衝突，編譯器將發出指示。using編譯命令匯入所有的名稱，包括可能並不需要的名稱。如果與區域性名稱發生衝突，則區域性名稱將覆蓋名稱空間版本，而編譯器並不會發出警告。另外，名稱空間的開放性意味著名稱空間的名稱可能分散在多個地方，這使得難以準確知道新增了哪些名稱。

using 使用

儘量少使用 using 指示

using namespace std;
複製程式碼

應該多使用 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;
複製程式碼

:: 範圍解析運算子

:: 使用

int count = 0;        // 全域性（::）的 count

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

int main() {
    ::count = 1;      // 設定全域性的 count 的值為 1

    A::count = 2;     // 設定類 A 的 count 為 2

    int count = 0;    // 區域性的 count
    count = 3;        // 設定區域性的 count 的值為 3

    return 0;
}
複製程式碼

enum 列舉型別

限定作用域的列舉型別

enum class open_modes { input, output, append };
複製程式碼

不限定作用域的列舉型別

enum color { red, yellow, green };
enum { floatPrec = 6, doublePrec = 10 };
複製程式碼

decltype

decltype 關鍵字用於檢查實體的宣告型別或表示式的型別及值分類。語法：

decltype ( expression )
複製程式碼

使用

// 尾置返回允許我們在引數列表之後宣告返回型別
template <typename It>
auto fcn(It beg, It end) -> decltype(*beg)
{
    // 處理序列
    return *beg;    // 返回序列中一個元素的引用
}
// 為了使用模板引數成員，必須用 typename
template <typename It>
auto fcn2(It beg, It end) -> typename remove_reference<decltype(*beg)>::type
{
    // 處理序列
    return *beg;    // 返回序列中一個元素的拷貝
}
複製程式碼

引用

左值引用

常規引用，一般表示物件的身份。

右值引用

右值引用就是必須繫結到右值（一個臨時物件、將要銷燬的物件）的引用，一般表示物件的值。

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

消除兩個物件互動時不必要的物件拷貝，節省運算儲存資源，提高效率。
能夠更簡潔明確地定義泛型函式。

引用摺疊

X& &、X& &&、X&& & 可摺疊成 X&
X&& && 可摺疊成 X&&

巨集

巨集定義可以實現類似於函式的功能，但是它終歸不是函式，而巨集定義中括弧中的“引數”也不是真的引數，在巨集展開的時候對 “引數” 進行的是一對一的替換。

成員初始化列表

好處

更高效：少了一次呼叫預設建構函式的過程。
有些場合必須要用初始化列表：

常量成員，因為常量只能初始化不能賦值，所以必須放在初始化列表裡面
引用型別，引用必須在定義的時候初始化，並且不能重新賦值，所以也要寫在初始化列表裡面
沒有預設建構函式的類型別，因為使用初始化列表可以不必呼叫預設建構函式來初始化，而是直接呼叫拷貝建構函式初始化。

initializer_list 列表初始化【C++11】

用花括號初始化器列表列表初始化一個物件，其中對應建構函式接受一個 std::initializer_list 引數.

initializer_list 使用

#include <iostream>
#include <vector>
#include <initializer_list>

template <class T>
struct S {
    std::vector<T> v;
    S(std::initializer_list<T> l) : v(l) {
         std::cout << "constructed with a " << l.size() << "-element list\n";
    }
    void append(std::initializer_list<T> l) {
        v.insert(v.end(), l.begin(), l.end());
    }
    std::pair<const T*, std::size_t> c_arr() const {
        return {&v[0], v.size()};  // 在 return 語句中複製列表初始化
                                   // 這不使用 std::initializer_list
    }
};

template <typename T>
void templated_fn(T) {}

int main()
{
    S<int> s = {1, 2, 3, 4, 5}; // 複製初始化
    s.append({6, 7, 8});      // 函式呼叫中的列表初始化

    std::cout << "The vector size is now " << s.c_arr().second << " ints:\n";

    for (auto n : s.v)
        std::cout << n << ' ';
    std::cout << '\n';

    std::cout << "Range-for over brace-init-list: \n";

    for (int x : {-1, -2, -3}) // auto 的規則令此帶範圍 for 工作
        std::cout << x << ' ';
    std::cout << '\n';

    auto al = {10, 11, 12};   // auto 的特殊規則

    std::cout << "The list bound to auto has size() = " << al.size() << '\n';

//    templated_fn({1, 2, 3}); // 編譯錯誤！“ {1, 2, 3} ”不是表示式，
                             // 它無型別，故 T 無法推導
    templated_fn<std::initializer_list<int>>({1, 2, 3}); // OK
    templated_fn<std::vector<int>>({1, 2, 3});           // 也 OK
}
複製程式碼

物件導向

物件導向程式設計（Object-oriented programming，OOP）是種具有物件概念的程式程式設計典範，同時也是一種程式開發的抽象方針。

物件導向三大特徵 —— 封裝、繼承、多型

封裝

把客觀事物封裝成抽象的類，並且類可以把自己的資料和方法只讓可信的類或者物件操作，對不可信的進行資訊隱藏。
關鍵字：public, protected, friendly, private。不寫預設為 friendly。

關鍵字	當前類	包內	子孫類	包外
public	√	√	√	√
protected	√	√	√	×
friendly	√	√	×	×
private	√	×	×	×

繼承

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

多型

多型，即多種狀態，在面嚮物件語言中，介面的多種不同的實現方式即為多型。
C++ 多型有兩種：靜態多型（早繫結）、動態多型（晚繫結）。靜態多型是通過函式過載實現的；動態多型是通過虛擬函式實現的。
多型是以封裝和繼承為基礎的。

靜態多型（早繫結）

函式過載

class A
{
public:
    void do(int a);
    void do(int a, int b);
};
複製程式碼

動態多型（晚繫結）

虛擬函式：用 virtual 修飾成員函式，使其成為虛擬函式

注意：

普通函式（非類成員函式）不能是虛擬函式
靜態函式（static）不能是虛擬函式
建構函式不能是虛擬函式（因為在呼叫建構函式時，虛表指標並沒有在物件的記憶體空間中，必須要建構函式呼叫完成後才會形成虛表指標）
行內函數不能是表現多型性時的虛擬函式，解釋見：虛擬函式（virtual）可以是行內函數（inline）嗎？：t.cn/E4WVXSP

動態多型使用

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();         // 呼叫圓形類裡面的方法
    shape2->calcArea();         // 呼叫矩形類裡面的方法
    delete shape1;
    shape1 = nullptr;
    delete shape2;
    shape2 = nullptr;
    return 0;
}
複製程式碼

虛解構函式

虛解構函式是為了解決基類的指標指向派生類物件，並用基類的指標刪除派生類物件。

虛解構函式使用

class Shape
{
public:
    Shape();                    // 建構函式不能是虛擬函式
    virtual double calcArea();
    virtual ~Shape();           // 虛解構函式
};
class Circle : public Shape     // 圓形類
{
public:
    virtual double calcArea();
    ...
};
int main()
{
    Shape * shape1 = new Circle(4.0);
    shape1->calcArea();    
    delete shape1;  // 因為Shape有虛解構函式，所以delete釋放記憶體時，先呼叫子類解構函式，再呼叫基類解構函式，防止記憶體洩漏。
    shape1 = NULL;
    return 0；
}
複製程式碼

純虛擬函式

純虛擬函式是一種特殊的虛擬函式，在基類中不能對虛擬函式給出有意義的實現，而把它宣告為純虛擬函式，它的實現留給該基類的派生類去做。

virtual int A() = 0;
複製程式碼

虛擬函式、純虛擬函式

CSDN . C++ 中的虛擬函式、純虛擬函式區別和聯絡：t.cn/E4WVQBI

類裡如果宣告瞭虛擬函式，這個函式是實現的，哪怕是空實現，它的作用就是為了能讓這個函式在它的子類裡面可以被覆蓋，這樣的話，這樣編譯器就可以使用後期繫結來達到多型了。純虛擬函式只是一個介面，是個函式的宣告而已，它要留到子類裡去實現。
虛擬函式在子類裡面也可以不過載的；但純虛擬函式必須在子類去實現。
虛擬函式的類用於 “實作繼承”，繼承介面的同時也繼承了父類的實現。當然大家也可以完成自己的實現。純虛擬函式關注的是介面的統一性，實現由子類完成。
帶純虛擬函式的類叫抽象類，這種類不能直接生成物件，而只有被繼承，並重寫其虛擬函式後，才能使用。抽象類和大家口頭常說的虛基類還是有區別的，在 C# 中用 abstract 定義抽象類，而在 C++ 中有抽象類的概念，但是沒有這個關鍵字。抽象類被繼承後，子類可以繼續是抽象類，也可以是普通類，而虛基類，是含有純虛擬函式的類，它如果被繼承，那麼子類就必須實現虛基類裡面的所有純虛擬函式，其子類不能是抽象類。

虛擬函式指標、虛擬函式表

虛擬函式指標：在含有虛擬函式類的物件中，指向虛擬函式表，在執行時確定。
虛擬函式表：在程式只讀資料段（.rodata section，見：目標檔案儲存結構:t.cn/E4WVBeF），存放…

虛繼承

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

底層實現原理與編譯器相關，一般通過虛基類指標和虛基類表實現，每個虛繼承的子類都有一個虛基類指標（佔用一個指標的儲存空間，4位元組）和虛基類表（不佔用類物件的儲存空間）（需要強調的是，虛基類依舊會在子類裡面存在拷貝，只是僅僅最多存在一份而已，並不是不在子類裡面了）；當虛繼承的子類被當做父類繼承時，虛基類指標也會被繼承。

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

虛繼承、虛擬函式

相同之處：都利用了虛指標（均佔用類的儲存空間）和虛表（均不佔用類的儲存空間）
不同之處：
虛擬函式不佔用儲存空間
虛擬函式表儲存的是虛擬函式地址
虛基類依舊存在繼承類中，只佔用儲存空間
虛基類表儲存的是虛基類相對直接繼承類的偏移
虛繼承
虛擬函式

模板類、成員模板、虛擬函式

模板類中可以使用虛擬函式
一個類（無論是普通類還是類别範本）的成員模板（本身是模板的成員函式）不能是虛擬函式

抽象類、介面類、聚合類

抽象類：含有純虛擬函式的類
介面類：僅含有純虛擬函式的抽象類
聚合類：使用者可以直接訪問其成員，並且具有特殊的初始化語法形式。滿足如下特點：
所有成員都是 public
沒有有定於任何建構函式
沒有類內初始化
沒有基類，也沒有 virtual 函式

記憶體分配和管理

malloc、calloc、realloc、alloca

malloc：申請指定位元組數的記憶體。申請到的記憶體中的初始值不確定。
calloc：為指定長度的物件，分配能容納其指定個數的記憶體。申請到的記憶體的每一位（bit）都初始化為 0。
realloc：更改以前分配的記憶體長度（增加或減少）。當增加長度時，可能需將以前分配區的內容移到另一個足夠大的區域，而新增區域內的初始值則不確定。
alloca：在棧上申請記憶體。程式在出棧的時候，會自動釋放記憶體。但是需要注意的是，alloca 不具可移植性, 而且在沒有傳統堆疊的機器上很難實現。alloca 不宜使用在必須廣泛移植的程式中。C99 中支援變長陣列 (VLA)，可以用來替代 alloca。

malloc、free

用於分配、釋放記憶體

malloc、free 使用

申請記憶體，確認是否申請成功

char *str = (char*) malloc(100);
assert(str != nullptr);
複製程式碼

釋放記憶體後指標置空

free(p); 
p = nullptr;
複製程式碼

new、delete

new / new[]：完成兩件事，先底層呼叫 malloc 分了配記憶體，然後呼叫建構函式（建立物件）。
delete/delete[]：也完成兩件事，先呼叫解構函式（清理資源），然後底層呼叫 free 釋放空間。
new 在申請記憶體時會自動計算所需位元組數，而 malloc 則需我們自己輸入申請記憶體空間的位元組數。

new、delete 使用

申請記憶體，確認是否申請成功

int main()
{
    T* t = new T();     // 先記憶體分配 ，再建構函式
    delete t;           // 先解構函式，再記憶體釋放
    return 0;
}
複製程式碼

定位 new

定位 new（placement new）允許我們向 new 傳遞額外的引數。

new (palce_address) type
new (palce_address) type (initializers)
new (palce_address) type [size]
new (palce_address) type [size] { braced initializer list }
複製程式碼

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

delete this 合法嗎？

Is it legal (and moral) for a member function to say delete this? 答案：t.cn/E4Wfcfl

合法，但：

必須保證 this 物件是通過 new（不是 new[]、不是 placement new、不是棧上、不是全域性、不是其他物件成員）分配的
必須保證呼叫 delete this 的成員函式是最後一個呼叫 this 的成員函式
必須保證成員函式的 delete this 後面沒有呼叫 this 了
必須保證 delete this 後沒有人使用了

如何定義一個只能在堆上（棧上）生成物件的類？

如何定義一個只能在堆上（棧上）生成物件的類?

答案：t.cn/E4WfDhP

只能在堆上

方法：將解構函式設定為私有

原因：C++ 是靜態繫結語言，編譯器管理棧上物件的生命週期，編譯器在為類物件分配棧空間時，會先檢查類的解構函式的訪問性。若解構函式不可訪問，則不能在棧上建立物件。

只能在棧上

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

原因：在堆上生成物件，使用 new 關鍵詞操作，其過程分為兩階段：第一階段，使用 new 在堆上尋找可用記憶體，分配給物件；第二階段，呼叫建構函式生成物件。將 new 操作設定為私有，那麼第一階段就無法完成，就不能夠在堆上生成物件。

智慧指標

C++ 標準庫（STL）中

標頭檔案：#include <memory>

C++ 98

std::auto_ptr<std::string> ps (new std::string(str))；
複製程式碼

受限於文章字數限制，後續部分請看【中篇】。

掃描下方二維碼，及時獲取更多網際網路求職面經、java、python、爬蟲、大資料等技術，和海量資料分享：公眾號後臺回覆“csdn”即可免費領取【csdn】和【百度文庫】下載服務；公眾號後臺回覆“資料”:即可領取5T精品學習資料、java面試考點和java面經總結，以及幾十個java、大資料專案，資料很全，你想找的幾乎都有

推薦閱讀

【微信事業群】二面面經

【C++】 C++知識點總結
2021-04-11
C++
C/C++知識要點總結之C++物件導向
2014-09-12
C++物件
C++中類相關知識點總結
2016-03-22
C++
C/C++重要知識點彙總
2016-04-14
C++
面試總結（C++基礎）
2016-08-18
面試C++
C++知識點大彙總
2021-06-25
C++
CSS知識點面試總結
2020-02-24
CSS面試
java面試知識點總結
2019-03-04
Java面試
Java 面試知識點總結
2019-02-12
Java面試
Objective c 知識總結 @property
2017-12-14
Object
Redis知識點&面試題總結
2022-11-23
Redis面試題
常用基礎知識面試（C++為主）
2018-08-04
面試C++
C++知識點：對於多執行緒的總結
2018-12-21
C++執行緒
面試總結：鵝廠Linux後臺開發面試筆試C++知識點參考筆記
2020-05-16
面試Linux筆試C++筆記
面試總結:Promise有關面試的知識點。
2018-10-03
面試Promise
Java基礎面試知識點總結
2019-03-09
Java面試
前端知識點總結—面試專用
2019-02-16
前端面試
30道CSS 面試知識點總結
2022-04-08
CSS面試
常見Java面試知識點總結
2018-03-30
Java面試
iOS基礎面試知識點總結
2017-02-28
iOS面試
Objective c 知識總結繼承
2017-12-14
Object繼承
C++知識概要
2021-05-21
C++
c++知識點
2020-12-16
C++
Java面試知識總結（一）-- 網路基礎
2020-07-28
Java面試
前端經典的JavaScript面試知識總結
2019-03-01
前端JavaScript面試
前端知識點總結——C3
2019-02-16
前端
C++基本知識點
2020-04-04
C++
C++基礎知識
2021-11-11
C++
C++常用知識列表
2016-03-11
C++
C/C++ Const 小知識
2019-03-27
C++
C/C++【知識點筆記】
2016-08-31
C++筆記
ES6常用知識點總結(上)
2019-04-07
關於 SSH 框架面試知識點的總結
2020-01-07
框架面試
Java集合類常見面試知識點總結
2019-10-18
Java面試
MySQL 鎖常見知識點&面試題總結
2022-07-01
MySql面試題
面試開發常用的 JavaScript 知識點總結
2016-08-07
面試JavaScript
MySQL面試之簡單知識和命令總結
2016-04-15
MySql面試
C++基礎知識篇：C++ 運算子
2020-11-28
C++

五萬字長文 C C++ 面試知識總結（上）

C/C++ 面試知識總結

C/C++

const

作用

使用

static

作用

this 指標

inline 行內函數

特徵

使用

編譯器對 inline 函式的處理步驟

優缺點

虛擬函式（virtual）可以是行內函數（inline）嗎？

虛擬函式內聯使用

assert()

使用

sizeof()

#pragma pack(n)

使用

位域

volatile

extern "C"

"C" 使用

struct 和 typedef struct

C 中

C++ 中

C++ 中 struct 和 class

區別

union 聯合

使用

C 實現 C++ 類

explicit（顯式）建構函式

explicit 使用

friend 友元類和友元函式

using

using 宣告

建構函式的 using 宣告【C++11】

using 指示

儘量少使用 using 指示 汙染名稱空間

using 使用

:: 範圍解析運算子

分類

:: 使用

enum 列舉型別

限定作用域的列舉型別

不限定作用域的列舉型別

decltype

使用

引用

左值引用

右值引用

引用摺疊

巨集

成員初始化列表

initializer_list 列表初始化【C++11】

initializer_list 使用

物件導向

封裝

繼承

多型

靜態多型（早繫結）

動態多型（晚繫結）

動態多型使用

虛解構函式

虛解構函式使用

純虛擬函式

虛擬函式、純虛擬函式

虛擬函式指標、虛擬函式表

虛繼承

虛繼承、虛擬函式

模板類、成員模板、虛擬函式

抽象類、介面類、聚合類

記憶體分配和管理

malloc、calloc、realloc、alloca

malloc、free

malloc、free 使用

new、delete

new、delete 使用

儘量少使用 `using 指示` 汙染名稱空間