1.多態(tài) ： 一個switch, 一個函數(shù)指針 重載，覆蓋，隱藏
const 引用必須在初始化列表中初始化
純虛函數(shù) virtual void eat()=0
VTABLE虛函數(shù)初始化表
C++ 不允許隱式轉換

2。多態(tài)分為四類 ： 參數(shù)多態(tài)，包含多態(tài)， 強制多態(tài)，重載多態(tài)

3.虛函數(shù)提供了一中更為靈活的動態(tài)性機制。虛函數(shù)允許函數(shù)調(diào)用與函數(shù)體之間的聯(lián)系在運行是建立（動態(tài)聯(lián)編）

4.對虛函數(shù)的定義的幾點說明 ：
（1）通過定義虛函數(shù)使用C++提供的多態(tài)性機制時，派生類應從其基類公有派生
（2）必須首先在基類定義為虛函數(shù)
（3）C++規(guī)定，當一個成員函數(shù)被聲明為虛函數(shù)后，其派生類中的同名函數(shù)都自動成為虛函數(shù)。
（4）一般是先定義基類指針，然后通過基類指針指向派生類，訪問虛函數(shù)獲取運行時多態(tài)性
（5）虛函數(shù)必須是類的成員函數(shù)，不能是友元函數(shù)，也不能是靜態(tài)成員函數(shù)
（6）內(nèi)聯(lián)函數(shù)不能是虛函數(shù)，因為內(nèi)聯(lián)函數(shù)是在編譯地確定位置，虛函數(shù)雖然定義在類內(nèi)部，但編譯時仍將其視為非內(nèi)聯(lián)
（7）構造函數(shù)不能是虛函數(shù)。因為虛函數(shù)作為運行過程中多態(tài)的基礎，主要是針對對象的，而構造函數(shù)是在對象產(chǎn)生之前運行的，因此虛構造函數(shù)無意義。
（8）析構函數(shù)可以是虛函數(shù)

5.編譯時的多態(tài) ： 函數(shù)重載
運行時的多態(tài) ： 虛函數(shù)和繼承

6.靜態(tài)聯(lián)編 ：
動態(tài)聯(lián)編：

7.純虛函數(shù)定義 ：是一個基類中說明的虛函數(shù)，它在該基類中沒有定義，但要求在它的派生類中必須定義自己的版本，或重新說明為純虛函數(shù)
8.純虛函數(shù)的特點：
（1）沒有函數(shù)體
（2）最后面“=0”并不表示函數(shù)返回值為0，它只起形式上的作用，告訴編譯系統(tǒng)“這是純虛函數(shù)”
（3）這是一個聲明語句，最后應有分號。
9.抽象類 ：不用來定義對象而只作為一種基本類型用作繼承的類，由于它常用作基類，通常稱為抽象基類
抽象類的特點 ：
（1）凡是包含純虛函數(shù)的類都是抽象類（至少一個純虛函數(shù)）
（2）抽象類只能作為其他類來使用，不能建立抽象類對象。因為純虛函數(shù)是不能被調(diào)用的，包含純虛函數(shù)的類是無法建立對象的，其純虛函數(shù)的實現(xiàn)由派生類給出
10. 重載，覆蓋，隱藏
　　　　成員函數(shù)被重載的特征：
　　　　　　（1）相同的范圍（在同一個類中）；
　　　　　　（2）函數(shù)名字相同；
　　　　　　（3）參數(shù)不同；
　　　　　　（4）virtual關鍵字可有可無。
　　　　覆蓋 ： 派生類函數(shù)覆蓋基類函數(shù) 特征：
　　　　　　（1）不同的范圍（分別位于派生類與基類）；
　　　　　　（2）函數(shù)名字相同；
　　　　　　（3）參數(shù)相同；
　　　　　　（4）基類函數(shù)必須有virtual關鍵字
　　　　隱藏 ： 派生類函數(shù)屏蔽了與其同名的基類

11.C++核心優(yōu)勢之一便于軟件的重用

12.C++中有兩個方面體現(xiàn)重用 ：

　　　　1. 面向對象的思想 ：繼承，多態(tài)，標準類庫

　　　　2.泛型程序設計（generic programming）的思想 ：模版機制，以及標準模版庫STL

13 泛型程序設計

　　　　將一些常用的數(shù)據(jù)結構 （比如鏈表，數(shù)組，二叉樹）和算法（比如排序，查找）寫成模版，以后則不論數(shù)據(jù)結構里放的是什么對象，算法針對什么樣的對象，則都不必重新實現(xiàn)數(shù)據(jù)結構，重新編寫算法

　　　　標準模版庫（Standard Template Library）： 一些常用數(shù)據(jù)結構和算法的模版的集合。由Ａlex Stepanov開發(fā),于1998年被添加進Ｃ++ 標準

　　13. 模版分類

　　　　函數(shù)模版(function template)

　　　　　　　　是獨立于類型的函數(shù)

　　　　　　　　可產(chǎn)生函數(shù)的特定版本

　　　　類模版（class template）

　　　　　　　　跟類相關的模版， 如vector

　　　　　　　　可產(chǎn)生類對特定類型的版本， 如vector <int>

　　14.模版的工作方式 ： 函數(shù)模版只是說明， 不能直接執(zhí)行，需要實例化為模版函數(shù)后才能執(zhí)行

　　15. 模版優(yōu)缺點 ：

　　　　　優(yōu)點：函數(shù)模版方法克服了Ｃ語言解決上述問題時用大量不同函數(shù)名表示相似功能的壞習慣

　　　　　　　　克服了宏定義不能進行參數(shù)類型檢查的弊端

　　　　　　　　克服了Ｃ++函數(shù)重載用相同函數(shù)名字重寫幾個函數(shù)的繁瑣

　　　　　缺點 ：調(diào)試比較困難

　　16.容器 ：可容納各種數(shù)據(jù)類型的數(shù)據(jù)結構

　　　　迭代器 ：可依次存取容器中元素的東西

　　　　算法 ：用來操作容器中的元素的函數(shù)模版，例如， STL用sort()來對一個vector中的數(shù)據(jù)進行排序，用find()來搜索一個list中的對象

　　　17.函數(shù)本身與他們操作的數(shù)據(jù)的結構和類型無關。

　　18.容器概述 ：

　　　　　　1）可以用于存放各種類型的數(shù)據(jù)（基本類型的變量，對象等）的數(shù)據(jù)結構

　　　　　　2）容器分為三大類：

　　　　　　　　　　1） 順序容器

　　　　　　　　　　　　　　vector ： 后不插入/刪除，直接訪問

　　　　　　　　　　　　　　deque ?: ?前/后部插入/刪除，直接訪問

　　　　　　　　　　　　　　list　　 : ?雙向鏈表，任意位置插入/刪除

　　　　　　　　　　2） ?關聯(lián)容器?

　　　　　　　　　　　　　　set : 快速查找，無重復元素

　　　　　　　　　　　　　　multiset : 快速查找，可有重復元素

　　　　　　　　　　　　　　map : 一對一映射，無重復元素，基于關鍵字查找

　　　　　　　　　　　　　　multimap ：一對一映射，可有重復元素，基于關鍵字查找

　　　　　　　　　　　　前兩者和稱為第一類容器

　　　　　　　　　　　3）容器適配器

　　　　　　　　　　　　　　stack : LIFO

　　　　　　　　　　　　　　queue : FIFO

　　　　　　　　　　　　　　priority_queue : 優(yōu)先級高的元素先出

　　　　　　　3）對象被插入容器中時，被插入的是對象的一個復制品

　　　　　　　　　　許多算法， 比如排序，查找，要求對容器中的元素進行比較，所以，放入容器的對象所屬的類，還應該實現(xiàn) == 和 < 運算符

　　19.順序容器簡介

　　　　1) vector 頭文件 <vector>

　　　　　　實際上就是個動態(tài)數(shù)組。隨機存取任何元素都能在常數(shù)時間完成。在尾端增刪元素具有較佳的性能。
　　　　2) deque 頭文件 <deque>
　　　　　　也是個動態(tài)數(shù)組，隨機存取任何元素都能在常數(shù)時間完成(但性能次于vector)。在兩端增刪元素具有較佳的性能。
　　　　3) list 頭文件 <list>
　　　　　　雙向鏈表，在任何位置增刪元素都能在常數(shù)時間完成。不支持隨機存取。
　　　　上述三種容器稱為順序容器，是因為元素的插入位置同元素的值無關。

　　20.關聯(lián)容器簡介　　

　　　　　　關聯(lián)式容器內(nèi)的元素是排序的，插入任何元素，都按相應的排序準則來確定其位置。關聯(lián)式容器的特點是在查找時具有非常好的性能。
　　　　　　1) set/multiset: 頭文件 <set>
　　　　　　　　set 即集合。set中不允許相同元素，multiset中允許存在相同的元素。
　　　　　　2) map/multimap: 頭文件 <map>
　　　　　　　　map與set的不同在于map中存放的是成對的key/value。并根據(jù)key對元素進行排序，可快速地根據(jù)key來檢索元素map同multimap的不同在于是否允許多個元素有相同的key值。
　　　　　 ?上述4種容器通常以平衡二叉樹方式實現(xiàn)，插入和檢索的時間都是 O(logN)

　　21.容器適配器簡介　

　　　　　1) stack :頭文件 <stack>
　　　　　　　　棧。是項的有限序列，并滿足序列中被刪除、檢索和修改的項只能是最近插入序列的項。即按照后進先出的原則
　　　　　2) queue :頭文件 <queue>
　　　　　　　　隊列。插入只可以在尾部進行，刪除、檢索和修改只允許從頭部進行。按照先進先出的原則。
　　　　　3）priority_queue :頭文件 <queue>
　　　　　　　　優(yōu)先級隊列。最高優(yōu)先級元素總是第一個出列

　　22.容器的共有成員函數(shù)

　　　　1) 所有標準庫容器共有的成員函數(shù)：
　　　　　　相當于按詞典順序比較兩個容器大小的運算符：
　　　　　　　　　　=, < , <= , > , >=, == , !=
　　　　　　　　　　empty : 判斷容器中是否有元素
　　　　　　　　　　max_size: 容器中最多能裝多少元素
　　　　　　　　　　size: 容器中元素個數(shù)
　　　　　　　　　　swap: 交換兩個容器的內(nèi)容

　　　　2) 只在第一類容器中的函數(shù)：
　　　　　　begin 返回指向容器中第一個元素的迭代器
　　　　　　end 返回指向容器中最后一個元素后面的位置的迭代器
　　　　　　rbegin 返回指向容器中最后一個元素的迭代器
　　　　　　rend 返回指向容器中第一個元素前面的位置的迭代器
　　　　　　erase 從容器中刪除一個或幾個元素
　　　　　　clear 從容器中刪除所有元素

　　　　head　　　　　　　　　　　　　　Tail

　　rend begin　　　　　　　　　　　　　rbegin end

　　23.迭代器　

　　　　1).用于指向第一類容器中的元素。有const 和非 const兩種。
　　　　2).通過迭代器可以讀取它指向的元素，通過非const迭代器還能修改其指向的元素。迭代器用法和指針類似。
　　　　3).定義一個容器類的迭代器的方法可以是：
　　　　　　容器類名::iterator 變量名;
　　　　　　　　或：
　　　　　　容器類名::const_iterator 變量名;
　　　　4).訪問一個迭代器指向的元素：
　　　　　　* 迭代器變量名

　　　　5).迭代器可以執(zhí)行++操作，以指向容器中的下一個元素，如果迭代器到達了容器中的最后一個元素的后面，則迭代器變成past-the-end值

　　　　　　注意：使用一個past-the-end值的迭代器來訪問對象是非法的

　　　　6）.STL中的迭代器

　　　　　　STL 中的迭代器按功能由弱到強分為5種：
　　　　　　　　1. 輸入：Input iterators 提供對數(shù)據(jù)的只讀訪問。
　　　　　　　　2. 輸出：Output iterators 提供對數(shù)據(jù)的只寫訪問
　　　　　　　　3. 正向：Forward iterators 提供讀寫操作，并能一次一個地向前推進迭代器。
　　　　　　　　4. 雙向：Bidirectional iterators提供讀寫操作，并能一次一個地向前和向后移動。
　　　　　　　　5. 隨機訪問：Random access iterators提供讀寫操作，并能在數(shù)據(jù)中隨機移動。

　　　　　　編號大的迭代器擁有編號小的迭代器的所有功能，能當作編號小的迭代器使用

　　　　　　7）不同迭代器所能進行的操作（功能）

　　　　　　　　　　所有迭代器： ++p, p ++
　　　　　　　　　　輸入迭代器： * p, p = p1, p == p1 , p!= p1
　　　　　　　　　　輸出迭代器： * p, p = p1
　　　　　　　　　　正向迭代器： 上面全部
　　　　　　　　　　雙向迭代器： 上面全部，--p, p --,
　　　　　　　　　　隨機訪問迭代器： 上面全部，以及：
　　　　　　　　　　　　　　　　　　　　　　　　　　　p+= i, p -= i,
　　　　　　　　　　　　　　　　　　　　　　　　　　　p + i： 返回指向 p 后面的第i個元素的迭代器
　　　　　　　　　　　　　　　　　　　　　　　　　　　p - i： 返回指向 p 前面的第i個元素的迭代器
　　　　　　　　　　　　　　　　　　　　　　　　　　　p[i]: p 后面的第i個元素的引用
　　　　　　　　　　　　　　　　　　　　　　　　　　　p < p1, p <= p1, p > p1, p>= p1

　　　　　　　　8）容器所支持的迭代器類別

　　　　　　　　　　　　容器 迭代器類別
　　　　　　　　　　　　vector 隨機
　　　　　　　　　　　　deque 隨機
　　　　　　　　　　　　list 雙向
　　　　　　　　　　　　set/multiset 雙向
　　　　　　　　　　　　map/multimap 雙向
　　　　　　　　　　　　stack 不支持迭代器
　　　　　　　　　　　　queue 不支持迭代器
　　　　　　　　　　　　priority_queue 不支持迭代器

　　24.算法簡介　

　　　　1）STL中提供能在各種容器中通用的算法，比如插入，刪除，查找，排序等。大約有70種標準算法。
　　　　　　算法就是一個個函數(shù)模板。
　　　　　　算法通過迭代器來操縱容器中的元素。許多算法需要兩個參數(shù)，一個是起始元素的迭代器，一個是終止元素的后面一個元素的迭代器。比如，排序和查找
　　　　　　有的算法返回一個迭代器。比如 find() 算法，在容器中查找一個元素，并返回一個指向該元素的迭代器。
　　　　　　算法可以處理容器，也可以處理C語言的數(shù)組

　　　　2）算法分類

　　　　　　變化序列算法
　　　　　　　　　　copy ,remove,fill,replace,random_shuffle,swap, …..
　　　　　　　　　　會改變?nèi)萜?br />　　　　　　非變化序列算法：
　　　　　　　　　　adjacent-find, equal, mismatch,find ,count, search, count_if, for_each, search_n
　　　　　　　　　　以上函數(shù)模板都在<algorithm> 中定義

　　　　　　此外還有其他算法，比如<numeric>中的算法

　　　　　3）find()　

　　　　　　template<class InIt, class T>
　　　　　　InIt find(InIt first, InIt last, const T& val);
　　　　　　first 和 last 這兩個參數(shù)都是容器的迭代器，它們給出了容器中的查找區(qū)間起點和終點。
　　　　　　　　這個區(qū)間是個左閉右開的區(qū)間，即區(qū)間的起點是位于查找范圍之中的，而終點不是
　　　　　　val參數(shù)是要查找的元素的值
　　　　　　函數(shù)返回值是一個迭代器。如果找到，則該迭代器指向被找到的元素。如果找不到，則該迭代器指向查找區(qū)間終點。

　　　　　　4).順序容器

　　　　　　　　除前述共同操作外，順序容器還有以下共同操作：
　　　　　　　　front() :返回容器中第一個元素的引用
　　　　　　　　back() : 返回容器中最后一個元素的引用
　　　　　　　　push_back(): 在容器末尾增加新元素
　　　　　　　　pop_back(): 刪除容器末尾的元素
　　　　　　　　比如，查 list::front 的help,得到的定義是：
　　　　　　　　　　reference front();
　　　　　　　　　　const_reference front() const;
　　　　　　　　　　list有兩個front函數(shù)

　　　　　　5）算法解釋

　　　　　　　　ostream_iterator<int> output(cout ,“*");
　　　　　　　　　　定義了一個 ostream_iterator 對象，可以通過cout輸出以 * 分隔的一個個整數(shù)
　　　　　　　　copy (v.begin(),v.end(),output);
　　　　　　　　　　導致v的內(nèi)容在 cout上輸出
　　　　　　　　　　copy 函數(shù)模板(算法）：
　　　　　　　　template<class InIt, class OutIt>
　　　　　　　　OutIt copy(InIt first, InIt last, OutIt x);
　　　　　　　　　　本函數(shù)對每個在區(qū)間[0, last - first)中的N執(zhí)行一次 *(x+N) = * ( first + N) ，返回 x + N
　　　　　　　　對于copy (v.begin(),v.end(),output);
　　　　　　　　　　first 和 last 的類型是 vector<int>::const_iterator
　　　　　　　　　　output 的類型是 ostream_iterator<int>

　25.list容器

　　　　在任何位置插入刪除都是常數(shù)時間， 不支持隨機存取，除了具有所有順序容器都有的成員函數(shù)外，還支持8個成員函數(shù) ：

　　　　　　　　push_front : 在前面插入

　　　　　　　　pop_front : 刪除前面的元素

　　　　　　　　sort ：排序（list 不支持STL的算法sort）

　　　　　　　　remove : 刪除和指定值相等的所有元素

　　　　　　　　unique : 刪除所有和前一個元素相同的元素

　　　　　　　　merge : 合并兩個鏈表，并清空被合并的那個

　　　　　　　　reverse : 顛倒鏈表

　　　　　　　　splice : 在指定位置前面插入另一鏈表中的一個或多個元素，并在另一鏈表中刪除被插入的元素

　　26. sort

　　　　　　sort 實際上是快速排序，時間復雜度 O(n*log(n));
　　　　　　　　平均性能最優(yōu)。但是最壞的情況下，性能可能非常差。
　　　　　　　　如果要保證“最壞情況下”的性能，那么可以使用stable_sort
　　　　　　stable_sort
　　　　　　　　stable_sort 實際上是歸并排序（將兩個已經(jīng)排序的序列合并成一個序列），特點是能保持相等元素之間的先后次序
　　　　　　　　在有足夠存儲空間的情況下，復雜度為 n * log(n)，否則復雜度為 n * log(n) * log(n)
　　　　　　stable_sort 用法和 sort相同
　　　　　　　　排序算法要求隨機存取迭代器的支持，所以list 不能使用排序算法，要使用list::sort

　　　　　　partial_sort : 部分排序，直到 前 n 個元素就位即可
　　　　　　nth_element : 排序，直到第 n個元素就位，并保證比第n個元素小的元素都在第 n 個元素之前即可　　　　　　
　　　　　　partition: 改變元素次序，使符合某準則的元素放在前面

?

轉載于:https://www.cnblogs.com/cxw825873709/p/3446341.html

《新程序員》：云原生和全面數(shù)字化實踐50位技術專家共同創(chuàng)作，文字、視頻、音頻交互閱讀

總結

以上是生活随笔為你收集整理的C++(2013.11.27)的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。