面向物件的程式設計的主要思想

和資料封裝其中，以提高程式的重用性，靈活性和可擴充套件性。類是建立物件的模板，一個類可以建立多個物件。物件是類的例項化。

類是抽象的，不佔用儲存空間；而物件具體的，佔用儲存空間。

面向物件有三大特性：封裝，繼承，多型。

 

1.C++的三大特性為：繼承，多型，封裝

 （1）繼承。一個物件直接使用另一個物件的屬性和方法。

優點：1.減少重複的程式碼。

   2.繼承是多型的前提。

   3.繼承增加了類的耦合性。

缺點：1.繼承在編譯時刻就定義了，無法在執行時刻改變父類繼承的實現；

   2.

父類通常至少定義了子類的部分行為，父類的改變都可能影響子類的行為；

   3.如果繼承下來的子類不適合解決新問題，父類必須重寫或替換，那麼這種依賴關係就限制了靈活性，最終限制了複用性。

繼承的方式有三種分別為公有繼承（public）,保護繼承（protect），私有繼承（private）。

 

虛繼承：

為了解決從不同途徑繼承來的同名的資料成員在記憶體中有不同的拷貝造成資料不一致問題，將共同基類設定為虛基類。這時從不同的路徑繼承過來的同名數據成員在記憶體中就只有一個拷貝，同一個函式名也只有一個對映。這樣不僅就解決了二義性問題，也節省了記憶體，避免了資料不一致的問題。

class 派生類名：virtual 繼承方式 基類名

virtual是關鍵字，宣告該基類為派生類的虛基類。

在多繼承情況下，虛基類關鍵字的作用範圍和繼承方式關鍵字相同，只對緊跟其後的基類起作用。

聲明瞭虛基類之後，虛基類在進一步派生過程中始終和派生類一起，維護同一個基類子物件的拷貝。

 

（2）多型。

C++中有兩種多型，稱為動多型（執行期多型）和靜多型（編譯期多型），

多型：是對於不同物件接收相同訊息時產生不同的動作。C++的多型性具體體現在執行和編譯兩個方面：

在程式執行時的多型性通過繼承和虛擬函式來體現；

在程式編譯時多型性體現在函式和運算子的過載上；

虛擬函式

就是多型的具體表現，虛擬函式的作用是允許在派生類中重新定義與基類同名的函式，並且可以通過基類指標或引用來訪問基類和派生類中的同名函式。

虛擬函式如何實現的？

虛擬函式是通過一張虛擬函式表實現的，有多少個虛擬函式，就有多少個指標；在這個表中，主要是一個類的虛擬函式的地址表，這張表解決了繼承、覆蓋的問題；實際上在編譯的時候，編譯器會自動加上虛表虛擬函式的作用實現動態聯編，也就是說在程式執行階段動態的選擇合適的成員函式，在定義了虛擬函式之後，可以在基類的派生類中對虛擬函式重新定義。虛表的使用方法是如果派生類在自己定義中沒有修改基類的虛擬函式，我們就指向基類的虛擬函式；如果派生類改寫了基類的虛擬函式，這時續表則將原來指向基類的虛擬函式的地址替換為指向自身虛擬函式的指標。必須通過基類型別的引用或指標進行函式呼叫才會發生多型

 

過載，是指“同一識別符號”在同一作用域的不同場合具有不同的語義，這個識別符號可以是函式名或運算子

 

介面的多種不同實現方式即為多型。

優點：1.大大提高了程式碼的可複用性；

   2.提高了了程式碼的可維護性，可擴充性；

        缺點： 1）易讀性比較不好，除錯比較困難

                    2）模板只能定義在.h檔案中，當工程大了之後，編譯時間十分的變態

 

 （3）封裝。隱藏物件的屬性和實現細節，僅僅對外提供介面和方法。

優點： 1）隔離變化；2）便於使用； 3）提高重用性； 4）提高安全性

缺點： 1）如果封裝太多，影響效率； 2）使用者不能知道程式碼具體實現。

 

過載（overload）和覆蓋（override）：

 

過載：寫一個與已有函式同名但是引數表不同的函式；

覆蓋：虛擬函式總是在派生類中被改寫。

 

派生類

      派生類的定義格式如下：

 

      class <派生類名>：[繼承方式]<基類名1>

                                 [，[繼承方式]<基類名2>，...，[繼承方式]<基類名n>]

 

      {

              <派生類新增的資料成員和成員函式定義>

      };

      說明：

      （1）定義派生類關鍵字可以是class或者是struct，兩者區別是：用class定義派生類，預設的繼承方式是private，用struct定義派生類，預設的繼承方式為public。新增加的成員預設屬性也是class對應private屬性，struct對應public屬性。

      （2）基類不能被派生類繼承的兩類函式是建構函式和解構函式。

 

1.C和C++的區別

1、主要區別：

C語言是面向過程的程式設計，它最重要的特點是函式，通過main函式來呼叫各個子函式。程式執行的順序都是程式設計師事先決定好的。

C++是面向物件的程式設計，類是它的主要特點，在程式執行過程中，先由主main函式進入，定義一些類，根據需要執行類的成員函式，過程的概念被淡化了，以類驅動程式執行，類就是物件，所以我們稱之為面向物件程式設計。面向物件在分析和解決問題的時候，將涉及到的資料和資料的操作封裝在類中，通過類可以建立物件，以事件或訊息來驅動物件執行處理。

2、聯絡：c是c++的子集，所以大部c語言程式都可以不加修改的拿到c++下使用。

 

2.C++和JAVA區別

Java面向物件，沒有指標，編寫效率高，執行效率較低。

java記憶體自動回收(GC垃圾回收機制)，多執行緒程式設計。

JAVA的應用在高層，C++在中介軟體和底層

c++用解構函式回收垃圾，java自動回收（GC演算法）

Java比C++程式可靠性更高

Java語言不需要程式對記憶體進行分配和回收

Java語言中沒有指標的概念，引入了真正的陣列

Java用介面(Interface)技術取代C++程式中的多繼承性

 

3. const 有什麼用途

 主要有三點：

   1：定義只讀變數，即常量

   2：修飾函式的引數和函式的返回值

const可以修飾函式的返回值，引數及，函式的定義體，被const修飾會受到強制的保護，能防止意外的修改，從而提高函式的健壯性。

   3： 修飾函式的定義體，這裡的函式為類的成員函式，被const修飾的成員函式代表不修改成員變數的值。

 

3. 指標和引用的區別

    1：引用是變數的一個別名，內部實現是隻讀指標

    2：引用只能在初始化時被賦值，其他時候值不能被改變，指標的值可以在任何時候被改變

    3：引用不能為NULL，指標可以為NULL

    4：引用變數記憶體單元儲存的是被引用變數的地址

    5：“sizeof 引用" = 指向變數的大小 ， "sizeof 指標"= 指標本身的大小

    6：引用可以取地址操作，返回的是被引用變數本身所在的記憶體單元地址

7：引用使用在原始碼級相當於普通的變數一樣使用，做函式引數時，內部傳遞的實際是變數地址

 

4. C++中有了malloc / free , 為什麼還需要 new / delet e

  1,malloc與free是C++/C語言的標準庫函式，new/delete是C++的運算子。它們都可用於申請動態記憶體和釋放記憶體。

  2,對於非內部資料型別的物件而言，光用malloc/free無法滿足動態物件的要求。

     物件在建立的同時要自動執行建構函式，物件在消亡之前要自動執行解構函式。

     由於malloc/free是庫函式而不是運算子，不在編譯器控制權限之內，不能夠把執行建構函式和解構函式的任務強加於malloc/free。

  3,因此C++語言需要一個能完成動態記憶體分配和初始化工作的運算子new，以一個能完成清理與釋放記憶體工作的運算子delete。注意new/delete不是庫函式。

new/delete、malloc/free底層實現原理：

概述：new/delete的底層實現是呼叫malloc/free函式實現的，而malloc/free的底層實現也不是直接操作記憶體而是呼叫系統API實現的。

 

5.delete與 delete []區別

delete只會呼叫一次解構函式，而delete[]會呼叫每一個成員的解構函式。

 

6. 編寫類String 的建構函式，解構函式，拷貝建構函式和賦值函式

https://blog.csdn.net/zz460833359/article/details/46651401

 

7. 單鏈表的逆置

/**

 * Definition for singly-linked list.

 * struct ListNode {

 *     int val;

 *     ListNode *next;

 *     ListNode(int x) : val(x), next(NULL) {}

 * };

 */

class Solution {

public:

    ListNode* reverseList(ListNode* head) {

        if (head == NULL || head->next == NULL) return head;

        ListNode* rHead = reverseList(head->next); // 反轉得到新連結串列的頭節點

        head->next->next = head; // 當前節點的下一個節點的next指標反轉過來

        head->next = NULL; // 設定新連結串列的尾節點

        return rHead;

    }

}; 8. 堆和棧的區別  

  一個由C/C++編譯的程式佔用的記憶體分為以下幾個部分

  1、棧區（stack）―   由編譯器自動分配釋放 ，存放函式的引數值，區域性變數的值等。其操作方式類似於資料結構中的棧。

  2、堆區（heap） ―   一般由程式設計師分配釋放， 若程式設計師不釋放，程式結束時可能由OS回收 。

     注意它與資料結構中的堆是兩回事，分配方式倒是類似於連結串列，呵呵。

  3、全域性區（靜態區）（static）― 全域性變數和靜態變數的儲存是放在一塊的，

     初始化的全域性變數和靜態變數在一塊區域， 未初始化的全域性變數和未初始化的靜態變數在相鄰的另一塊區域。 - 程式結束後有系統釋放

  4、文字常量區  ―常量字串就是放在這裡的。 程式結束後由系統釋放

  5、程式程式碼區―存放函式體的二進位制程式碼。

 

棧區與堆區的區別：

1）堆和棧中的儲存內容：棧存區域性變數、函式引數等。堆儲存使用new、malloc申請的變數等；

2）申請方式：棧記憶體由系統分配，堆記憶體由自己申請；

3）申請後系統的響應：棧——只要棧的剩餘空間大於所申請空間，系統將為程式提供記憶體，否則將報異常提示棧溢位。

堆——首先應該知道作業系統有一個記錄空閒記憶體地址的連結串列，當系統收到程式的申請時，會遍歷該連結串列，尋找第一個空間大於所申請空間的堆結點，然後將該結點從空閒結點連結串列 中刪除，並將該結點的空間分配給程式；

4）申請大小的限制：Windows下棧的大小一般是2M，堆的容量較大；

5）申請效率的比較：棧由系統自動分配，速度較快。堆使用new、malloc等分配，較慢；

總結：棧區優勢在處理效率，堆區優勢在於靈活；

記憶體模型：自由區、靜態區、動態區；

根據c/c++物件生命週期不同，c/c++的記憶體模型有三種不同的記憶體區域，即：自由儲存區，動態區、靜態區。

自由儲存區：區域性非靜態變數的儲存區域，即平常所說的棧；

動態區： 用new ，malloc分配的記憶體，即平常所說的堆；

靜態區：全域性變數，靜態變數，字串常量存在的位置；

注：程式碼雖然佔記憶體，但不屬於c/c++記憶體模型的一部分；

 

13. 標頭檔案種的ifndef/define/endif 是幹什麼用的

      主要用於防止重複定義巨集和重複包含標頭檔案

 

8、動態規劃的本質

答：動歸，本質上是一種劃分子問題的演算法，站在任何一個子問題的處理上看，當前子問題的提出都要依據現有的類似結論，而當前問題的結論是後面問題求解的鋪墊。任何動態規劃都是基於儲存的演算法，核心是狀態轉移方程。

 

解構函式的呼叫情況

解構函式呼叫的次序是先派生類的析構後基類的析構，也就是說在基類的的析構呼叫的時候,派生類的資訊已經全部銷燬了。定義一個物件時先呼叫基類的建構函式、然後呼叫派生類的建構函式；析構的時候恰好相反：先呼叫派生類的解構函式、然後呼叫基類的解構函式。

 

11、結構與聯合有和區別？

 (1). 結構和聯合都是由多個不同的資料型別成員組成, 但在任何同一時刻, 聯合中只存放了一個被選中的成員（所有成員共用一塊地址空間）, 而結構的所有成員都存在（不同成員的存放地址不同）。 

 

(2). 對於聯合的不同成員賦值, 將會對其它成員重寫, 原來成員的值就不存在了, 而對於結構的不同成員賦值是互不影響的。

 

14.有哪幾種情況只能用intialization list 而不能用assignment?

答案：當類中含有const、reference 成員變數；基類的建構函式都需要初始化表。

 

15. C++是不是型別安全的？

答案：不是。兩個不同型別的指標之間可以強制轉換（用reinterpret cast)。C#是型別安全的。

 

16. main 函式執行以前，還會執行什麼程式碼？

答案：全域性物件的建構函式會在main 函式之前執行。

 

17. 描述記憶體分配方式以及它們的區別?

1） 從靜態儲存區域分配。記憶體在程式編譯的時候就已經分配好，這塊記憶體在程式的整個執行期間都存在。例如全域性變數，static 變數。

2） 在棧上建立。在執行函式時，函式內區域性變數的儲存單元都可以在棧上建立，函式執行結束時這些儲存單元自動被釋放。棧記憶體分配運算內置於處理器的指令集。

3） 從堆上分配，亦稱動態記憶體分配。程式在執行的時候用malloc 或new 申請任意多少的記憶體，程式設計師自己負責在何時用free 或delete 釋放記憶體。動態記憶體的生存期由程式設計師決定，使用非常靈活，但問題也最多。

 

 18.分別寫出BOOL,int,float,指標型別的變數a 與“零”的比較語句。

答案：

BOOL : if ( !a ) or if(a)

int : if ( a == 0)

float : const EXPRESSION EXP = 0.000001

if ( a < EXP && a >-EXP)

pointer : if ( a != NULL) or if(a == NULL)

 

19.請說出const與#define 相比，有何優點？

答案：const作用：定義常量、修飾函式引數、修飾函式返回值三個作用。被Const修飾的東西都受到強制保護，可以預防意外的變動，能提高程式的健壯性。

1） const 常量有資料型別，而巨集常量沒有資料型別。編譯器可以對前者進行型別安全檢查。而對後者只進行字元替換，沒有型別安全檢查，並且在字元替換可能會產生意料不到的錯誤。

2） 有些整合化的除錯工具可以對const 常量進行除錯，但是不能對巨集常量進行除錯。

 

20.簡述陣列與指標的區別？

陣列要麼在靜態儲存區被建立（如全域性陣列），要麼在棧上被建立。指標可以隨時指向任意型別的記憶體塊。

(1)修改內容上的差別

char a[] = “hello”;

a[0] = ‘X’;

char *p = “world”; // 注意p 指向常量字串

p[0] = ‘X’; // 編譯器不能發現該錯誤，執行時錯誤

(2) 用運算子sizeof 可以計算出陣列的容量（位元組數）。sizeof(p),p 為指標得到的是一個指標變數的位元組數，而不是p 所指的記憶體容量。C++/C 語言沒有辦法知道指標所指的記憶體容量，除非在申請記憶體時記住它。注意當陣列作為函式的引數進行傳遞時，該陣列自動退化為同類型的指標。

char a[] = "hello world";

char *p = a;

cout<< sizeof(a) << endl; // 12 位元組

cout<< sizeof(p) << endl; // 4 位元組

計算陣列和指標的記憶體容量

void Func(char a[100])

{

cout<< sizeof(a) << endl; // 4 位元組而不是100 位元組

}

 

第21題： int (*s[10])(int) 表示的是什麼？

int (*s[10])(int) 函式指標陣列，每個指標指向一個int func(int param)的函式。

 

第23題：將程式跳轉到指定記憶體地址

 

要對絕對地址0x100000賦值，我們可以用(unsigned int*)0x100000 = 1234;那麼要是想讓程式跳轉到絕對地址是0x100000去執行，應該怎麼做？

　　*((void (*)( ))0x100000 ) ( );　　首先要將0x100000強制轉換成函式指標,即:　　(void (*)())0x100000　　然後再呼叫它:　　*((void (*)())0x100000)();　　用typedef可以看得更直觀些:　　typedef void(*)() voidFuncPtr;　　*((voidFuncPtr)0x100000)();

 

第24題：int id[sizeof(unsigned long)];這個對嗎？為什麼？

 答案:正確 這個 sizeof是編譯時運算子，編譯時就確定了  ,可以看成和機器有關的常量。

 

第26題：const  與 #define 的比較，const有什麼優點?

（1） const 常量有資料型別，而巨集常量沒有資料型別。編譯器可以對前者進行型別安全檢查。而對後者只進行字元替換，沒有型別安全檢查，並且在字元替換可能會產生意料不到的錯誤（邊際效應） 。

（2）  有些整合化的除錯工具可以對 const 常量進行除錯，但是不能對巨集常量進行除錯。

 

第29題：基類的解構函式不是虛擬函式，會帶來什麼問題？

【參考答案】派生類的解構函式用不上，會造成資源的洩漏。

 

第30題：全域性變數和區域性變數有什麼區別？是怎麼實現的？作業系統和編譯器是怎麼知道的？

【參考答案】

生命週期不同：

全域性變數隨主程式建立和建立，隨主程式銷燬而銷燬；區域性變數在區域性函式內部，甚至區域性迴圈體等內部存在，退出就不存在；

使用方式不同：通過聲明後全域性變數程式的各個部分都可以用到；區域性變數只能在區域性使用；分配在棧區。 

作業系統和編譯器通過記憶體分配的位置來知道的，全域性變數分配在全域性資料段並且在程式開始執行的時候被載入。區域性變數則分配在堆疊裡面 。

 

C++類在記憶體中的空間分配

注意點1：一個類物件的地址就是類所包含的這一片記憶體空間的首地址，這個首地址對應具體該類某一個成員變數的地址。

注意點2：類的成員函式不佔用棧空間

類本身是不佔有記憶體的，可是 如果類生成例項那麼將會在記憶體中分配一塊記憶體來儲存這個類。

文字檔案和二進位制檔案存取

文字檔案和二進位制檔案的定義：

 

計算機在實體記憶體上面存放的都是二進位制，所以文字檔案和二進位制檔案的主要區別是在邏輯上的而不是物理上的。而從檔案的編碼方式來看，檔案可以分為文字檔案和二進位制檔案。文字檔案是基於字元編碼的檔案，常見的有ASCII、Unicode等，二進位制檔案是基於值編碼的檔案，可以看成是變長編碼，你可以根據自己的需要，決定多少個位元代表一個值。

 

文字檔案和二進位制檔案的儲存：

 

二進位制檔案就是把記憶體中的資料按其在記憶體中儲存的形式原樣輸出到磁碟中存放，即存放的是資料的原形式。

文字檔案是把資料的終端形式的二進位制資料輸出到磁碟上存放，即存放的是資料的終端形式

在實際儲存中最好是將資料分成字元資料和非字元資料兩類:

如果儲存的是字元資料，無論採用文字檔案還是二進位制檔案都是沒有任何區別的，所以討論使用文字檔案還是二進位制檔案是沒有意義的。

如果儲存的是非字元資料，又要看我們使用的情況來決定:

a:如果是需要頻繁的儲存和訪問資料，那麼應該採取二進位制檔案進行存放，這樣可以節省儲存空間和轉換時間。

B:如果需要頻繁的向終端顯示資料或從終端讀入資料，那麼應該採用文字檔案進行存放，這樣可以節省轉換時間。

 

文字檔案的開啟方式和二進位制檔案開啟方式的區別：

(1)文字模式中回車被當成一個字元'\n'，在檔案中如果讀到0x1B,文字模式會認為這是檔案結束符，會按照一定方式對資料做相應的轉換。

(2)二進位制模式中'\n'會被認為是兩個字元0x0D，0x0A;在讀到0x1B時，二進位制模式不會對檔案進行處理。

 

C和C++中struct的區別

1. C中struct是使用者自定義資料型別（UDT）；

C++中struct是抽象資料型別（ADT），支援成員函式的定義，（C++中的struct能繼承，能實現多型）。

2. C中struct是沒有許可權的設定的，且struct中只能是一些變數的集合體，可以封裝資料卻不可以隱藏資料，而且成員不可以是函式。

C++中，struct的成員預設訪問說明符為public（為了與C相容），class中的預設訪問限定符為private，struct增加了訪問許可權，且可以和類一樣有成員函式。

struct作為類的一種特例是用來自定義資料結構的。一個結構標記聲明後，

3. C中必須在結構標記前加上struct，才能做結構型別名（除：typedef struct class{};）;

C++中結構體標記（結構體名）可以直接作為結構體型別名使用，此外結構體struct在C++中被當作類的一種特例。

 

求出兩個長連結串列交叉的那個結點

方法一

兩個沒有環的連結串列如果是相交於某一結點，如上圖所示，這個結點後面都是共有的。所以如果兩個連結串列相交，那麼兩個連結串列的尾結點的地址也是一樣的。程式實現時分別遍歷兩個單鏈表，直到尾結點。判斷尾結點地址是否相等即可。時間複雜度為O(L1+L2)。

如何找到第一個相交結點？判斷是否相交的時候，記錄下兩個連結串列的長度，算出長度差len，接著先讓較長的連結串列遍歷len個長度，然後兩個連結串列同時遍歷，判斷是否相等，如果相等，就是第一個相交的結點。

void Is_2List_Intersect(LinkList L1, LinkList L2) {

    if (L1 == NULL || L2 == NULL) {

        exit(ERROR);

    }

    LinkList p = L1;

    LinkList q = L2;

    int L1_length = 0;

    int L2_length = 0;

    int len = 0;

 

    while (p->next) {

        L1_length ++;

        p = p->next;

    }

    while (q->next) {

        L2_length ++;

        q = q->next;

    }

 

 

 

    printf("p: = %d\n", p);

    printf("q: = %d\n", q);

 

    printf("L1_length: = %d\n", L1_length);

    printf("L2_length: = %d\n", L2_length);

 

 

 

    if (p == q) {

        printf(" 相交\n");

 

        /*p重新指向短的連結串列 q指向長連結串列*/

        if (L1_length > L2_length) {

            len = L1_length - L2_length;

            p = L2->next;

            q = L1->next;

        }

        else {

            len = L2_length - L1_length;

            p = L1->next;

            q = L2->next;

        }

 

        while (len) {

            q = q->next;

            len--;

        }

        while (p != q) {

            p = p->next;

            q = q->next;

        }

        printf("相交的第一個結點是：%d\n", p->data );

 

    }

 

    else {

        printf("不相交 \n");

    }

 

}

 

用巨集表示一年的秒數

#define SECONDS_PER_YEAR 60*60*24*365(UL)

 

c程式的執行過程

1.hello程式的生命週期是從一個高階c語言程式開始的，然後為了在系統上執行hello.c程式，每條c語句都必須被其他程式轉化為一系列的低階機器語言指令。

2.預處理階段。前處理器（cpp）根據以字元#開頭的命令，修改原始的C程式。#include <stdio.h>命令告訴前處理器讀取系統標頭檔案stdio.h的內容，並將它直接插入到程式文字中。結果就得到另一個C程式，通常以.i作為副檔名。

3.編譯階段。編譯器（ccl）將文字檔案hello.i翻譯成文字檔案hello.s。它包含一個組合語言程式。組合語言程式中的每條語句都以一種標準的文字格式確切地描述了一條低階機器語言指令。組合語言為不同編譯器提供了通用的輸出語言。

4.彙編階段。彙編器（as）將hello.s翻譯成機器語言指令。並將結果儲存在目標檔案hello.o中。hello.o是一種二進位制檔案。它的位元組編碼是機器語言指令而不是字元。

5.連線階段。hello程式呼叫printf函式。它是c編譯器都會提供的標準c庫中的一個函式。printf函式存在於一個名為printf.o的單獨的預編譯好的目標檔案中，而這個檔案必須以某種方式合併到我們的hello.o程式中。聯結器就是負責這種合併的。

c語言中，常見資料型別的位元組數
32位編譯器
char ：1個位元組
char*（即指標變數）: 4個位元組（32位的定址空間是2^32, 即32個bit，也就是4個位元組。同理64位編譯器）
short int : 2個位元組
int：  4個位元組
unsigned int : 4個位元組
float:  4個位元組
double:   8個位元組
long:   4個位元組
long long:  8個位元組
unsigned long:  4個位元組

64位編譯器
char ：1個位元組
char*(即指標變數): 8個位元組
short int : 2個位元組
int：  4個位元組
unsigned int : 4個位元組
float:  4個位元組
double:   8個位元組
long:   8個位元組
long long:  8個位元組

unsigned long:  8個位元組 

 

c++常見容器，vector容器capacity和size區別，如何動態增長

   在Vector容器中有以下幾個關於大小的函式

size()      返回容器的大小

empty()   判斷容器是否為空

max_size()      返回容器最大的可以儲存的元素

capacity()       返回容器當前能夠容納的元素數量

1. 容器的大小一旦超過capacity的大小，vector會重新配置內部的儲存器，導致和vector元素相關的所有reference、pointers、iterator都會失效。

2.記憶體的重新配置會很耗時間。

Vector記憶體擴充套件方式

          vector記憶體成長方式可歸結以下三步曲:

（1）另覓更大空間；

（2）將原資料複製過去；

（3）釋放原空間三部曲。

 

vector遍歷有哪幾種方式（儘可能多）

for (size_t i =0; i < vec.size(); i ++) {

        }

for_each(ivec.begin(),ivec.end(),fun);

 

cv:Mat 有幾種訪問方式

初始化

初始化一個Mat檔案出來一般有兩種形式：

// 1、imread

Mat src = imread("csdn.png");

 

//2、create

Mat src;

if(src.empty())

{

    src.create(Size size, VC_8UC3);

}

訪問方式：

at<type>(i,j)訪問

例：int ROWS = 100; // height

int COLS = 200; // width

Mat img1(ROWS , COLS , CV_32FC1);   

for (int i=0; i<ROWS ; i++) 

{ 

    for (int j=0; j<COLS ; j++) 

    { 

        img1.at<float>(i,j) = 3.2f; 

    } 

}

方式2： ptr<type>(i) [j] 方式

例：for (int i=0; i<ROWS ; i++)  

{  

    float* pData1=img5.ptr<float>(i); 

    for (int j=0; j<COLS ; j++)  

    {  

        pData1[j] = 3.2f;  

    }  

}

例：方式3：img.data + step[0]*i + step[1]*j 方式

 

相關推薦