目錄

1.part1 C++基礎(chǔ)

1 C++特點

2 說說C語言和C++的區(qū)別

3 說說 C++中 struct 和 class 的區(qū)別

4 include頭文件的順序以及雙引號""和尖括號<>的區(qū)別

5 說說C++結(jié)構(gòu)體和C結(jié)構(gòu)體的區(qū)別

6 導(dǎo)入C函數(shù)的關(guān)鍵字是什么，C++編譯時和C有什么不同？

7 C++從代碼到可執(zhí)行二進制文件的過程

8 說說 static關(guān)鍵字的作用

9 數(shù)組和指針的區(qū)別

10 說說什么是函數(shù)指針，如何定義函數(shù)指針，有什么使用場景

11 靜態(tài)變量什么時候初始化？

12 nullptr調(diào)用成員函數(shù)可以嗎？為什么？

13 說說什么是野指針，怎么產(chǎn)生的，如何避免

14 說說靜態(tài)局部變量，全局變量，局部變量的特點，以及使用場景

15 說說內(nèi)聯(lián)函數(shù)和宏函數(shù)的區(qū)別

17 說說new和malloc的區(qū)別，各自底層實現(xiàn)原理。

18 說說const和define的區(qū)別。

19 說說C++中函數(shù)指針和指針函數(shù)的區(qū)別。

20 說說const int *a, int const *a, const int a, int *const a, const int *const a分別是什么，有什么特點。

21 說說使用指針需要注意什么？

22 說說內(nèi)聯(lián)函數(shù)和函數(shù)的區(qū)別，內(nèi)聯(lián)函數(shù)的作用。

23 簡述C++有幾種傳值方式，之間的區(qū)別是什么？

24 簡述const（星號）和（星號）const的區(qū)別

2.C++內(nèi)存?

1 簡述堆和棧的區(qū)別

2 簡述C++的內(nèi)存管理

3. 內(nèi)存泄露及解決辦法：

3 malloc和局部變量分配在堆還是棧？

4 程序有哪些section，分別的作用？程序啟動的過程？怎么判斷數(shù)據(jù)分配在棧上還是堆上？

5 初始化為0的全局變量在bss還是data

6 簡述C++中內(nèi)存對齊的使用場景

3?面向?qū)ο?/p>

1 簡述一下什么是面向?qū)ο?/p>

2 簡述一下面向?qū)ο蟮娜筇卣?/p>

3簡述一下 C++ 的重載和重寫，以及它們的區(qū)別

4 說說 C++ 的重載和重寫是如何實現(xiàn)的

5 說說構(gòu)造函數(shù)有幾種，分別什么作用

6 只定義析構(gòu)函數(shù)，會自動生成哪些構(gòu)造函數(shù)

7 說說一個類，默認會生成哪些函數(shù)

8 說說 C++ 類對象的初始化順序，有多重繼承情況下的順序

9 簡述下向上轉(zhuǎn)型和向下轉(zhuǎn)型

10 簡述下深拷貝和淺拷貝，如何實現(xiàn)深拷貝

11 簡述一下 C++ 中的多態(tài)

12 說說為什么要虛析構(gòu)，為什么不能虛構(gòu)造

14 說說類繼承時，派生類對不同關(guān)鍵字修飾的基類方法的訪問權(quán)限

15 簡述一下移動構(gòu)造函數(shù)，什么庫用到了這個函數(shù)？

16 構(gòu)造函數(shù)為什么不能被聲明為虛函數(shù)？

17 簡述一下什么是常函數(shù)，有什么作用

18 說說什么是虛繼承，解決什么問題，如何實現(xiàn)？

19 簡述一下虛函數(shù)和純虛函數(shù)，以及實現(xiàn)原理

21 說說C++中虛函數(shù)與純虛函數(shù)的區(qū)別

22 說說 C++ 中什么是菱形繼承問題，如何解決？

23 請問構(gòu)造函數(shù)中的能不能調(diào)用虛方法

24 請問拷貝構(gòu)造函數(shù)的參數(shù)是什么傳遞方式，為什么

25 如何理解抽象類？

26 什么是多態(tài)？除了虛函數(shù)，還有什么方式能實現(xiàn)多態(tài)？

27 簡述一下虛析構(gòu)函數(shù)，什么作用

28 說說什么是虛基類，可否被實例化？

29 簡述一下拷貝賦值和移動賦值？

30 仿函數(shù)了解嗎？有什么作用

31 C++ 中哪些函數(shù)不能被聲明為虛函數(shù)？

32?解釋下 C++ 中類模板和模板類的區(qū)別

32 虛函數(shù)表里存放的內(nèi)容是什么時候?qū)戇M去的？

1.part1 C++基礎(chǔ)

1 C++特點

2 說說C語言和C++的區(qū)別

3 說說 C++中 struct 和 class 的區(qū)別

4 include頭文件的順序以及雙引號""和尖括號<>的區(qū)別

5 說說C++結(jié)構(gòu)體和C結(jié)構(gòu)體的區(qū)別

6 導(dǎo)入C函數(shù)的關(guān)鍵字是什么，C++編譯時和C有什么不同？

int func(int a);
int (*f)(int a);
f = &func;

指針函數(shù)：int *fun(int x,int y);
函數(shù)指針：int (*fun)(int x,int y);

int* createArray(int size) {int* arr = (int*)malloc(size * sizeof(int));// 對 arr 進行初始化或其他操作return arr;
}

nt (*operation)(int, int); // 函數(shù)指針的聲明
operation = &add; // 將函數(shù)指針指向 add 函數(shù)
int result = operation(3, 4); // 調(diào)用 add 函數(shù)進行計算

1. const int a; //指的是a是一個常量，不允許修改。
2. const int *a; //a指針所指向的內(nèi)存里的值不變，即（*a）不變
3. int const *a; //同const int *a;
4. int *const a; //a指針所指向的內(nèi)存地址不變，即a不變
5. const int *const a; //都不變，即（*a）不變，a也不變

2.C++內(nèi)存?

????????

1 簡述堆和棧的區(qū)別

2 簡述C++的內(nèi)存管理

1. 內(nèi)存分配方式 ：

在 C++ 中，內(nèi)存分成 5 個區(qū)，他們分別是 堆、棧、自由存儲區(qū)、全局 / 靜態(tài)存儲區(qū)和常量存儲區(qū) 。

棧 ，在執(zhí)行函數(shù)時，函數(shù)內(nèi)局部變量的存儲單元都可以在棧上創(chuàng)建，函數(shù)執(zhí)行結(jié)束時這些存儲單元

自動被釋放。

堆 ，就是那些由 new 分配的內(nèi)存塊，一般一個 new 就要對應(yīng)一個 delete 。

自由存儲區(qū) ，就是那些由 malloc 等分配的內(nèi)存塊，和堆是十分相似的，不過是用 free 來結(jié)束自己的

生命。

全局 / 靜態(tài)存儲區(qū) ，全局變量和靜態(tài)變量被分配到同一塊內(nèi)存中

常量存儲區(qū) ，這是一塊比較特殊的存儲區(qū)，里面 存放的是常量，不允許修改。

2. 常見的內(nèi)存錯誤及其對策 ：

（1）內(nèi)存分配未成功，卻使用了它。

（2）內(nèi)存分配雖然成功，但是尚未初始化就引用它。

（3）內(nèi)存分配成功并且已經(jīng)初始化，但操作越過了內(nèi)存的邊界。

（4）忘記了釋放內(nèi)存，造成內(nèi)存泄露。

（5）釋放了內(nèi)存卻繼續(xù)使用它。

對策：

（1）定義指針時，先初始化為 NULL 。

（2）用 malloc 或 new 申請內(nèi)存之后，應(yīng)該 立即檢查 指針值是否為 NULL 。防止使用指針值為 NULL

的內(nèi)存。

（3）不要忘記為數(shù)組和動態(tài)內(nèi)存 賦初值 。防止將未被初始化的內(nèi)存作為右值使用。

（4）避免數(shù)字或指針的下標 越界 ，特別要當(dāng)心發(fā)生 “ 多 1” 或者 “ 少 1” 操作

（5） 動態(tài)內(nèi)存的申請與釋放必須配對，防止 內(nèi)存泄漏

（6） 用 free 或 delete 釋放了內(nèi)存之后，立即將指針 設(shè)置為 NULL ，防止 “ 野指針 ”

（7）使用智能指針。

3. 內(nèi)存泄露及解決辦法：

什么是內(nèi)存泄露？

簡單地說就是 申請了一塊內(nèi)存空間，使用完畢后沒有釋放掉 。

（1） new 和 malloc 申請資源使用后，沒有用 delete 和 free 釋放；

（2）子類繼承父類時，父類析構(gòu)函數(shù)不是虛函數(shù)。

（3） Windows 句柄資源使用后沒有釋放。

怎么檢測？

第一： 良好的編碼習(xí)慣，使用了內(nèi)存分配的函數(shù)，一旦使用完畢 , 要記得使用其相應(yīng)的函數(shù)釋放掉 。

第二： 將分配的內(nèi)存的指針以鏈表的形式自行管理 ，使用完畢之后從鏈表中刪除，程序結(jié)束時可檢 查改鏈表。

第三： 使用智能指針。

第四：一些常見的工具插件，如 ccmalloc 、 Dmalloc 、 Leaky 、 Valgrind 等等。

3 malloc和局部變量分配在堆還是棧？

malloc 是在 堆上分配內(nèi)存 ，需要程序員自己回收內(nèi)存；局部變量是在 棧中分配內(nèi)存 ，超過作用域就自動回收。

4 程序有哪些section，分別的作用？程序啟動的過程？怎么判斷數(shù)據(jù)分配在棧上還是堆上？

一個程序有哪些 section ：

如上圖， 從低地址到高地址，一個程序由代碼段、數(shù)據(jù)段、 BSS 段組成。

1. 數(shù)據(jù)段： 存放程序中 已初始化的 全局變量和靜態(tài)變量的一塊內(nèi)存區(qū)域。

2. 代碼段： 存放程序執(zhí)行代碼的一塊內(nèi)存區(qū)域。只讀，代碼段的頭部還會包含一些只讀的常數(shù)變量。

3. BSS 段：存放程序中 未初始化的 全局變量和靜態(tài)變量的一塊內(nèi)存區(qū)域。

4. 可執(zhí)行程序在運行時又會多出兩個區(qū)域：堆區(qū)和棧區(qū)。

堆區(qū)： 動態(tài)申請內(nèi)存用。堆從低地址向高地址增長。

棧區(qū)： 存儲局部變量、函數(shù)參數(shù)值。棧從高地址向低地址增長。是一塊連續(xù)的空間。

5. 最后還有一個 文件映射區(qū) ，位于堆和棧之間。 堆 heap ：由 new 分配的內(nèi)存塊，其釋放由程序員控制（一個 new 對應(yīng)一個 delete ）

棧 stack ：是那些編譯器在需要時分配，在不需要時自動清除的存儲區(qū)。存放局部變量、函數(shù)參數(shù)。

常量存儲區(qū) ：存放常量，不允許修改。

程序啟動的過程：

1. 操作系統(tǒng) 首先創(chuàng)建相應(yīng)的進程并分配私有的進程空間 ，然后操作系統(tǒng)的 加載器負責(zé)把可執(zhí)行文件的

數(shù)據(jù)段和代碼段映射到進程的虛擬內(nèi)存空間中。

2. 加載器讀入可執(zhí)行程序的導(dǎo)入符號表 ，根據(jù)這些符號表可以查找出該可執(zhí)行程序的所有依賴的動態(tài)

鏈接庫。

3. 加載器針對該程序的每一個動態(tài)鏈接庫調(diào)用 LoadLibrary

（1）查找對應(yīng)的動態(tài)庫文件，加載器為該動態(tài)鏈接庫確定一個合適的基地址。

（2）加載器讀取該動態(tài)鏈接庫的導(dǎo)入符號表和導(dǎo)出符號表，比較應(yīng)用程序要求的導(dǎo)入符號是否匹

配該庫的導(dǎo)出符號。

（3）針對該庫的導(dǎo)入符號表，查找對應(yīng)的依賴的動態(tài)鏈接庫，如有跳轉(zhuǎn)，則跳到 3

（4）調(diào)用該動態(tài)鏈接庫的初始化函數(shù)

4. 初始化應(yīng)用程序的全局變量，對于全局對象自動調(diào)用構(gòu)造函數(shù) 。

5. 進入應(yīng)用程序入口點函數(shù)開始執(zhí)行。

怎么判斷數(shù)據(jù)分配在棧上還是堆上：

首先局部變量分配在棧上；而通過 malloc 和 new 申請的空間是在堆上。

5 初始化為0的全局變量在bss還是data

BSS 段通常是指用來存放程序中 未初始化的或者初始化為 0 的 全局變量和靜態(tài)變量的一塊內(nèi)存區(qū)域。特點是可讀寫的， 在程序執(zhí)行之前 BSS 段會自動清 0 。

6 簡述C++中內(nèi)存對齊的使用場景

內(nèi)存對齊應(yīng)用于三種數(shù)據(jù)類型中： struct/class/union

struct/class/union 內(nèi)存對齊原則有四個：

1. 數(shù)據(jù)成員對齊規(guī)則 ：結(jié)構(gòu) (struct) 或聯(lián)合 (union) 的數(shù)據(jù)成員， 第一個數(shù)據(jù)成員放在 offset 為 0 的地

方 ，以后每個數(shù)據(jù)成員存儲的 起始位置要從該成員大小或者成員的子成員大小的整數(shù)倍開始 。

2. 結(jié)構(gòu)體作為成員 : 如果一個結(jié)構(gòu)里有某些結(jié)構(gòu)體成員 , 則結(jié)構(gòu)體成員要從其 內(nèi)部 " 最寬基本類型成

員 " 的整數(shù)倍地址開始存儲。 (struct a 里存有 struct b,b 里有 char,int ,double 等元素 , 那 b 應(yīng)該從 8 的

整數(shù)倍開始存儲 ) 。

3. 收尾工作 : 結(jié)構(gòu)體的總大小，也就是 sizeof 的結(jié)果， 必須是其內(nèi)部最大成員的 " 最寬基本類型成員 " 的

整數(shù)倍。不足的要補齊。 ( 基本類型不包括 struct/class/uinon) 。

4. sizeof(union) ，以結(jié)構(gòu)里面 size 最大元素為 union 的 size ，因為在某一時刻， union 只有一個成員真

正存儲于該地址。

?什么是內(nèi)存對齊？

那么什么是字節(jié)對齊？在 C 語言中，結(jié)構(gòu)體是一種復(fù)合數(shù)據(jù)類型，其構(gòu)成元素既可以是基本數(shù)據(jù)類型 （如int 、 long 、 float 等）的變量，也可以是一些復(fù)合數(shù)據(jù)類型（如數(shù)組、結(jié)構(gòu)體、聯(lián)合體等）的數(shù)據(jù)單 元。在結(jié)構(gòu)體中，編譯器為結(jié)構(gòu)體的每個成員按其自然邊界（ alignment ）分配空間。 各個成員按照它 們被聲明的順序在內(nèi)存中順序存儲，第一個成員的地址和整個結(jié)構(gòu)體的地址相同。

為了使 CPU 能夠?qū)ψ兞窟M行快速的訪問，變量的起始地址應(yīng)該具有某些特性， 即所謂的 “ 對齊 ” ，比如 4 字 節(jié)的 int 型，其起始地址應(yīng)該位于 4 字節(jié)的邊界上，即起始地址能夠被 4 整除 ，也即 “ 對齊 ” 跟數(shù)據(jù)在內(nèi)存中 的位置有關(guān)。如果一個變量的內(nèi)存地址正好位于它長度的整數(shù)倍，他就被稱做自然對齊。

為什么要字節(jié)對齊？

為了快速準確的訪問，若沒有字節(jié)對齊則會出現(xiàn)多次訪問浪費時間。

舉例說明（定義一個 char 和 int 型數(shù)據(jù)不按照字節(jié)對齊存儲的情況需要多次訪問）

3?面向?qū)ο?/strong>

1 簡述一下什么是面向?qū)ο?

1. 面向?qū)ο笫且环N編程思想，把一切東西看成是一個個對象 ，把這些對象擁有的屬性變量和操作這些 屬性變量的函數(shù)打包成一個類來表示

2. 面向過程和面向?qū)ο蟮膮^(qū)別

面向過程：根據(jù)業(yè)務(wù)邏輯從上到下寫代碼

面向?qū)ο?#xff1a; 將數(shù)據(jù)與函數(shù)綁定到一起，進行封裝 ，加快開發(fā)程序，減少重復(fù)代碼的重寫過程。

2 簡述一下面向?qū)ο蟮娜筇卣?

? 面向?qū)ο蟮娜筇卣魇?/span> 封裝、繼承、多態(tài)

1. 封裝： 將數(shù)據(jù)和操作數(shù)據(jù)的方法進行有機結(jié)合，隱藏對象的屬性和實現(xiàn)細節(jié)，僅對外公開接口來和對象進行 交互。 封裝 本質(zhì)上是一種管理 ，不想給別人看到的，我們使用 protected/private 把成員

封裝起來。開放一些共有的成員函數(shù)對成員合理的訪問。

2. 繼承： 可以使用現(xiàn)有類的所有功能 ，并在無需重新編寫原來的類的情況下對這些功能進行擴展。

三種繼承方式。

3. 多態(tài)： 用父類型別的指針指向其子類的實例，然后通過父類的指針調(diào)用實際子類的成員函數(shù) 。實現(xiàn)多態(tài)，有二種方式， 重寫，重載 。

?

3簡述一下 C++ 的重載和重寫，以及它們的區(qū)別

1. 重寫

是指 派生類中存在重新定義的函數(shù)。其函數(shù)名，參數(shù)列表，返回值類型，所有都必須同基類中被重

寫的函數(shù)一致。只有函數(shù)體不同（花括號內(nèi)） ，派生類對象調(diào)用時會調(diào)用派生類的重寫函數(shù)，不會

調(diào)用被重寫函數(shù)。重寫的基類中被重寫的函數(shù)必須有 virtual 修飾。

#include<bits/stdc++.h>
using namespace std;
class A
{
public:
virtual void fun()
{
cout << "A";
}
};
class B :public A
{
public:
virtual void fun()
{
cout << "B";
}
};
int main(void)
{
A* a = new B();
a->fun();//輸出B，A類中的fun在B類中重寫
}

1. 重載

我們在平時寫代碼中會用到幾個函數(shù)但是他們的實現(xiàn)功能相同，但是有些細節(jié)卻不同。 函數(shù)重載是

指同一可訪問區(qū)內(nèi)被聲明的幾個具有不同參數(shù)列（參數(shù)的類型，個數(shù)，順序不同）的同名函數(shù)，根

據(jù)參數(shù)列表確定調(diào)用哪個函數(shù)，重載不關(guān)心函數(shù)返回類型。

#include<bits/stdc++.h>
using namespace std;
class A
{
void fun() {};
void fun(int i) {};
void fun(int i, int j) {};
void fun1(int i,int j){};
};

4 說說 C++ 的重載和重寫是如何實現(xiàn)的

1. 重載： C++ 利用命名傾軋（ name mangling ）技術(shù)，來改名函數(shù)名，區(qū)分參數(shù)不同的同名函數(shù)。命 名傾軋是在編譯階段完成的。 編譯時將參數(shù)類型加入以區(qū)分不同。

2. 重寫： 在 基類的函數(shù)前加上 virtual 關(guān)鍵字，在派生類中重寫該函數(shù)，運行時將會根據(jù)對象的實際類 型來調(diào)用相應(yīng)的函數(shù) 。如果 對象類型是派生類，就調(diào)用派生類的函數(shù)；如果對象類型是基類，就調(diào) 用基類的函數(shù)。

虛函數(shù)需要注意的地方：

用 virtual 關(guān)鍵字申明 的函數(shù)叫做虛函數(shù)，虛函數(shù)肯定是類的成員函數(shù)。 存在虛函數(shù)的類都有一個一維的虛函數(shù)表叫做虛表 ， 類的對象有一個指向虛表開始的虛指針。 虛表是和類對應(yīng)的，虛表指針是和對象對應(yīng)的。 多態(tài)性是一個接口多種實現(xiàn) ，是面向?qū)ο蟮暮诵?#xff0c;分為類的多態(tài)性和函數(shù)的多態(tài)性。 重寫用虛函數(shù)來實現(xiàn)，結(jié)合動態(tài)綁定 。 純虛函數(shù) 是虛函數(shù)再加上 = 0 。 抽象類 是指包括至少一個 純虛函數(shù)的類 。

純虛函數(shù)： virtual void fun()=0 。即抽象類 必須在子類實現(xiàn)這個函數(shù)，即先有名稱，沒有內(nèi)容 ，在

派生類實現(xiàn)內(nèi)容。

5 說說構(gòu)造函數(shù)有幾種，分別什么作用

C++ 中的構(gòu)造函數(shù)可以分為 4 類：默認構(gòu)造函數(shù)、初始化構(gòu)造函數(shù)、拷貝構(gòu)造函數(shù)、移動構(gòu)造函數(shù)。 1. 默認構(gòu)造函數(shù)和初始化構(gòu)造函數(shù)。 在定義類的對象的時候，完成對象的初始化工作。

注意： 有了有參的構(gòu)造了，編譯器就不提供默認的構(gòu)造函數(shù)。

class Student
{
public:
//默認構(gòu)造函數(shù)
Student()
{
num=1001;
age=18;
}
//初始化構(gòu)造函數(shù)
Student(int n,int a):num(n),age(a){}
private:
int num;
int age;
};
int main()
{
//用默認構(gòu)造函數(shù)初始化對象S1
Student s1;
//用初始化構(gòu)造函數(shù)初始化對象S2
Student s2(1002,18);
return 0;
}

2. 拷貝構(gòu)造函數(shù)

#include "stdafx.h"
#include "iostream.h"
class Test
{
int i;
int *p;
public:
Test(int ai,int value)
{
i = ai;
p = new int(value);
}
~Test()
{
delete p;
}
Test(const Test& t)
{
this->i = t.i;
this->p = new int(*t.p);
}
};
//復(fù)制構(gòu)造函數(shù)用于復(fù)制本類的對象
int main(int argc, char* argv[])
{
Test t1(1,2);
Test t2(t1);//將對象t1復(fù)制給t2。注意復(fù)制和賦值的概念不同
return 0;
}

賦值構(gòu)造函數(shù)默認實現(xiàn)的是值拷貝（淺拷貝） 。

3. 移動構(gòu)造函數(shù)。用于將其他類型的變量，隱式轉(zhuǎn)換為本類對象。 下面的轉(zhuǎn)換構(gòu)造函數(shù)，將 int 類型的 r轉(zhuǎn)換為 Student 類型的對象，對象的 age 為 r ， num 為 1004.

Student(int r)
｛
int num=1004；
int age= r；
｝

6 只定義析構(gòu)函數(shù)，會自動生成哪些構(gòu)造函數(shù)

只定義了析構(gòu)函數(shù)，編譯器將自動為我們生成 拷貝構(gòu)造函數(shù)和默認構(gòu)造函數(shù) 。

默認構(gòu)造函數(shù)和初始化構(gòu)造函數(shù)。 在定義類的對象的時候，完成對象的初始化工作。

class Student
{
public:
//默認構(gòu)造函數(shù)
Student()
{
num=1001;
age=18;
}
//初始化構(gòu)造函數(shù)
Student(int n,int a):num(n),age(a){}
private:
int num;
int age;
};
int main()
{
//用默認構(gòu)造函數(shù)初始化對象S1
Student s1;
//用初始化構(gòu)造函數(shù)初始化對象S2
Student s2(1002,18);
return 0;
}

#include "stdafx.h"
#include "iostream.h"
class Test
{
int i;
int *p;
public:
Test(int ai,int value)
{
i = ai;
p = new int(value);
}
~Test()
{
delete p;
}
Test(const Test& t)
{
this->i = t.i;
this->p = new int(*t.p);
}
};
//復(fù)制構(gòu)造函數(shù)用于復(fù)制本類的對象
int main(int argc, char* argv[])
{
Test t1(1,2);
Test t2(t1);//將對象t1復(fù)制給t2。注意復(fù)制和賦值的概念不同。
return 0;
}

class HasPtr
{
public:
HasPtr(const string& s = string()) :ps(new string(s)), i(0) {}
~HasPtr() { delete ps; }
private:
string * ps;
int i;
};

HasPtr f(HasPtr hp)
{
HasPtr ret = hp;
///... 其他操作
return ret;
}

class Empty
{
};

Empty()
{
}

Empty(const Empty& copy)
{
}

Empty& operator = (const Empty& copy)
{
}

~Empty()
{
}

include<iostream>
using namespace std;
int Add(int a,int b)//1
{
return a+b;
}
char Add(char a,char b)//2
{
return a+b;
}
int main()
{
cout<<Add(666,888)<<endl;//1
cout<<Add('1','2');//2
return 0;
}

#include <iostream>
using namespace std;
// #1 模板定義
template<class T>
struct TemplateStruct
{
TemplateStruct()
{
cout << sizeof(T) << endl;
}
};
// #2 模板顯示實例化
template struct TemplateStruct<int>;
// #3 模板具體化
template<> struct TemplateStruct<double>
{
TemplateStruct() {
cout << "--8--" << endl;
}
};
int main()
{
TemplateStruct<int> intStruct;
TemplateStruct<double> doubleStruct;
// #4 模板隱式實例化
TemplateStruct<char> llStruct;
}

#include<iostream>
using namespace std;
class CStu
{
public:
int a;
CStu()
{
a = 12;
}
void Show() const
{
//a = 13; //常函數(shù)不能修改數(shù)據(jù)成員
cout <<a << "I am show()" << endl;
}
};
int main()
{
CStu st;
st.Show();
system("pause");
return 0;
}

#include<iostream>
using namespace std;
class A{
public:
int _a;
};
class B :virtual public A
{
public:
int _b;
};
class C :virtual public A
{
public:
int _c;
};
class D :public B, public C
{
public:
int _d;
};
//菱形繼承和菱形虛繼承的對象模型
int main()
{
D d;
d.B::_a = 1;
d.C::_a = 2;
d._b = 3;
d._c = 4;
d._d = 5;
cout << sizeof(D) << endl;
return 0;
}

class Person{
public:
//虛函數(shù)
virtual void GetName(){
cout<<"PersonName:xiaosi"<<endl;
};
};
class Student:public Person{
public:
void GetName(){
cout<<"StudentName:xiaosi"<<endl;
};
};
int main(){
//指針
Person *person = new Student();
//基類調(diào)用子類的函數(shù)
person->GetName();//StudentName:xiaosi
}

//抽象類
class Person{
public:
//純虛函數(shù)
virtual void GetName()=0;
};
class Student:public Person{
public:
Student(){
};
void GetName(){
cout<<"StudentName:xiaosi"<<endl;
};
};
int main(){
Student student;
}

class Base
{
public:
virtual void func() = 0;
};
#include<iostream>
using namespace std;
class Base
{
public:
virtual void func() = 0;
};
class Derived :public Base
{
public:
void func() override
{
cout << "哈哈" << endl;
}
};
int main()
{
Base *b = new Derived();
b->func();
return 0;
}

class A
{
public:
virtual void foo()
{
cout<<"A::foo() is called"<<endl;
}
};
class B:public A
{
public:
void foo()
{
cout<<"B::foo() is called"<<endl;
}
};
int main(void)
{
A *a = new B();
a->foo(); // 在這里，a雖然是指向A的指針，但是被調(diào)用的函數(shù)(foo)卻是B的!
return 0;
}

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

class TimeKeeper
{
public:
TimeKeeper() {}
virtual ~TimeKeeper() {}
};

class TimeKeeper
{
public:
TimeKeeper() {}
~TimeKeeper() {} //非virtual的
};
//都繼承與TimeKeeper
class AtomicClock :public TimeKeeper{};
class WaterClock :public TimeKeeper {};
class WristWatch :public TimeKeeper {};

TimeKeeper* getTimeKeeper()
{
//返回一個指針，指向一個TimeKeeper派生類的動態(tài)分配對象
}

TimeKeeper* ptk = getTimeKeeper();
delete ptk;

class TimeKeeper
{
public:
TimeKeeper() {}
virtual ~TimeKeeper() {}
};

class A
class B1:public virtual A;
class B2:public virtual A;
class D:public B1,public B2;

class Animal {/* ... */ };
class Tiger : virtual public Animal { /* ... */ };
class Lion : virtual public Animal { /* ... */ }
int main( )
{
Liger lg ;
/*既然我們已經(jīng)在Tiger和Lion類的定義中聲明了"virtual"關(guān)鍵字，于是下面的代碼編譯OK */
int weight = lg.getWeight();
}

class Func{
public:
void operator() (const string& str) const {
cout<<str<<endl;
}
};
Func myFunc;
myFunc("helloworld!");
>>>helloworld!

bool LengthIsLessThanFive(const string& str) {
return str.length()<5;
}
int res=count_if(vec.begin(), vec.end(), LengthIsLessThanFive);

bool LenthIsLessThan(const string& str, int len) {
return str.length()<len;
}

class ShorterThan {
public:
explicit ShorterThan(int maxLength) : length(maxLength) {}
bool operator() (const string& str) const {
return str.length() < length;
}
private:
const int length;
};