【C++提高編程-04】----C++之Vector容器實戰

🎩 歡迎來到技術探索的奇幻世界👨?💻

📜 個人主頁：@一倫明悅-CSDN博客

?🏻 作者簡介：?C++軟件開發、Python機器學習愛好者

🗣??互動與支持：💬評論?? ? ?👍🏻點贊?? ? ?📂收藏?? ? 👀關注+

如果文章有所幫助，歡迎留下您寶貴的評論，

點贊加收藏支持我，點擊關注，一起進步！

前言

正文

01-Vector容器簡介

?02-Vector容器構造函數簡介

03-Vector容器賦值操作

04-Vector容器容量和大小

05-Vector容器插入和刪除

06-Vector容器數據存取

07-Vector互換容器

總結

前言

? ? ? ?vector是C++中非常常用的容器，提供了動態數組的靈活性和高效的隨機訪問能力，是處理動態數據集合的重要工具之一。在使用時需要注意選擇合適的數據結構來滿足需求，并考慮到vector的性能特征。

正文

01-Vector容器簡介

? ? ?vector是C++標準模板庫（STL）中的一個容器，它提供了動態數組的功能，允許在數組的尾部高效地插入或刪除元素。下面是關于vector容器的詳細分析和介紹：
特點：

vector是一個動態數組，可以根據需要自動調整大小。
支持隨機訪問，可以通過索引快速訪問元素。
在尾部插入或刪除元素的開銷低，但在中間或頭部插入或刪除元素開銷較大。
內部基于數組實現，內存是連續存儲的，因此支持高效的隨機訪問。

創建vector：

可以通過std::vector<T> v;來創建一個空的vector，其中T是存儲的元素類型。
也可以通過初始化列表初始化vector，比如std::vector<int> v = {1, 2, 3};。

常用操作：

push_back(element)：在vector的尾部插入一個元素。
pop_back()：刪除vector的尾部元素。
size()：返回vector中的元素個數。
empty()：判斷vector是否為空。
at(index)：訪問指定索引位置的元素。
back()：返回最后一個元素的引用。
front()：返回第一個元素的引用。
clear()：清空vector中的所有元素。
遍歷vector：
可以使用迭代器或范圍循環遍歷vector中的元素。
例如：
std::vector<int> v = {1, 2, 3, 4};
for (int i : v) {std::cout << i << " ";
}
性能分析：

vector在尾部插入和刪除元素的時間復雜度是O(1)。
隨機訪問的時間復雜度是O(1)。
在中間或頭部插入或刪除元素，需要移動后續元素，時間復雜度為O(n)。

注意事項：

當vector的大小超過預分配的內存時，會重新分配更大的內存，這可能導致性能開銷。
插入或刪除操作會導致重新分配內存和元素的移動，需要注意性能消耗。

?02-Vector容器構造函數簡介

? ? 在 C++ 的標準模板庫（STL）中，不同類型的容器（如 vector、map、set 等）都有各自的構造函數，用于創建容器對象并進行初始化。下面簡要介紹一些常見容器的構造函數：

? vector<T> v;：構造一個空的 vector，存儲類型為 T。

? vector<T> v(n);：構造一個包含 n 個元素的 vector，每個元素值為類型 T 的默認值。??

? vector<T> v(n, value);：構造一個包含 n 個元素的 vector，并每個元素初始化為 value。

? vector<T> v(begin, end);：使用迭代器指定的范圍內的元素來構造 vector

????????下面給出具體代碼分析應用過程：這段代碼主要演示了使用不同方式構造vector容器并進行操作，代碼分析如下：

頭文件包含：
- #include<iostream>：包含 C++ 標準輸入輸出流頭文件。
- using namespace std;：使用?std?命名空間，避免在后續代碼中需要寫出?std::前綴。
- #include <vector>：包含 C++ STL 中的 vector 容器頭文件。
函數定義：
- void printVector(vector<int> & v)：定義了一個用于輸出?vector<int>?容器元素的函數，并使用引用方式傳入容器，以便在函數內部可以修改容器的內容。
主測試函數?test01：
- 創建一個空的?vector<int>?容器?v1，并通過?push_back?方法向容器中添加元素。
- 調用?printVector?函數輸出?v1?容器的內容。
- 使用區間構造方法，將?v1?的元素復制到?v2?容器中，并輸出?v2?內容。
- 使用?n?個元素相同的方式構造?v3?容器，其中包含 10 個值為 100 的元素，并輸出?v3?內容。
- 使用拷貝構造方式，將?v1?容器的內容拷貝構造到?v4?容器中，并輸出?v4?內容。
main?函數：
- 在?main?函數中調用?test01?函數以執行測試。
- 使用?system("pause");?使程序暫停，防止窗口一閃而過。

? ? ? ?總體來說，這段代碼展示了如何使用不同構造方式初始化vector容器，并演示了如何輸出容器中的元素。通過對不同構造方式的使用和輸出結果的比較，可以更好地理解vector容器的構造函數及其作用。

#include<iostream>
using namespace std;
#include <vector>// 容器構造函數 void printVector(vector<int> & v)   // 這里既然需要輸出容器，必然要傳入一個定義的容器變量，采用引用方式
{for (vector<int>::iterator it = v.begin(); it != v.end();it++){cout << *it << " ";}cout << endl;}void test01()
{vector<int>v1;   // 1、默認構造函數 for (int i = 0; i < 10;i++){v1.push_back(i);}// 調用一個輸出容器的函數printVector(v1);   // 這里函數以引用方式做傳入的參數，并且參數類型是vector<int>容器類型// 2、通過區間方式進行構造vector<int> v2(v1.begin(), v1.end());printVector(v2);// 3、n個elem方式構造vector<int>v3(10, 100);   // 指的是10個100printVector(v3);// 4、拷貝構造vector<int>v4(v1);   // 直接傳入就是拷貝構造printVector(v4);}int main() {test01();system("pause");return 0;
}

???????實例結果如下圖所示：??

03-Vector容器賦值操作

? ? vector容器的賦值操作可以通過多種方式進行，下面是對這些方式的詳細簡介：

賦值運算符?=：

可以使用?=?運算符將一個?vector?容器的內容賦值給另一個?vector?容器。
例如：vector<int> v1 = {1, 2, 3}; vector<int> v2 = v1;?將?v1?的內容賦值給?v2。

assign 函數：

assign?函數用于將指定范圍內的元素賦值給?vector?容器。
格式為?v.assign(first, last)，其中?first?和?last?是迭代器，指定了賦值范圍。
例如：vector<int> v; v.assign({4, 5, 6});?將?{4, 5, 6}?賦值給?v。

fill 函數：

fill?函數用于將容器中的所有元素替換為指定值。
格式為?v.fill(value)，其中?value?是要填充的值。
例如：vector<int> v(5); v.fill(10);?將?v?中的所有元素都填充為?10。

swap 函數：

swap?函數用于交換兩個?vector?容器的內容。
格式為?v1.swap(v2)，其中?v1?和?v2?是要交換內容的兩個容器。
例如：vector<int> v1 = {1, 2, 3}; vector<int> v2 = {4, 5, 6}; v1.swap(v2);?將?v1?和?v2?的內容進行交換。

? ? ? ?這些賦值操作提供了靈活的方式來修改?vector?容器的內容，可以根據具體需求選擇適合的方式進行賦值操作。

???????下面給出具體代碼分析應用過程：這段代碼演示了使用賦值操作符?=?和?assign?函數對vector容器進行賦值操作，下面是對代碼的簡要分析：

頭文件包含：
- 包含了?<iostream>?頭文件用于輸入輸出操作。
- 使用了?using namespace std;?聲明，避免了在后續代碼中需要加上?std::?命名空間前綴。
- 引入了?<vector>?頭文件，以使用vector容器。
函數定義：
- 定義了一個名為?printVector?的函數，用來輸出?vector<int>?容器中的元素。
測試函數?test01：
- 創建一個空的?vector<int>?容器?v1，并通過?push_back?方法向容器中添加元素。
- 使用printVector函數輸出?v1?容器的內容。
- 使用賦值操作符?=?將?v1?的內容賦值給另一個空的?vector<int>?容器?v2，并輸出?v2?的內容。
- 使用?assign?函數將?v1?的內容復制給另一個空的?vector<int>?容器?v3，并輸出?v3?的內容。
- 使用?assign?函數將?10?個值為?100?的元素賦值給另一個空的?vector<int>?容器?v4，并輸出?v4?的內容。
main?函數：
- 在?main?函數中調用?test01?函數以執行測試。
- 使用?system("pause");?使程序暫停，防止窗口一閃而過。

? ? ? ?總體來說，這段代碼演示了如何使用賦值操作符?=?和?assign?函數來對vector容器進行賦值操作。通過不同的賦值方式，可以將一個容器的內容復制給另一個容器，或者將指定范圍或固定值賦給容器，從而靈活地操作容器的內容。

#include<iostream>
using namespace std;
#include <vector>// 容器賦值操作 void printVector(vector<int> & v)   // 這里既然需要輸出容器，必然要傳入一個定義的容器變量，采用引用方式
{for (vector<int>::iterator it = v.begin(); it != v.end(); it++){cout << *it << " ";}cout << endl;}void test01()
{vector<int>v1;   // 1、默認構造函數 for (int i = 0; i < 10; i++){v1.push_back(i);}// 調用一個輸出容器的函數printVector(v1);   // 這里函數以引用方式做傳入的參數，并且參數類型是vector<int>容器類型// 賦值操作 operator=vector<int>v2;v2 = v1;printVector(v2);// assign 賦值   區間使用，assign([a,b));vector<int>v3;v3.assign(v1.begin(), v1.end());   //v1.begin(), v1.end()printVector(v3);// assign 賦值   區間使用，assign([a,b));vector<int>v4;v4.assign(10, 100);   //賦值，和構造有區別printVector(v4);}int main() {test01();system("pause");return 0;
}

???????實例結果如下圖所示：??

04-Vector容器容量和大小

? ? ? 在 C++ STL 中，vector?容器的容量（capacity）和大小（size）是兩個重要的概念，它們表示了容器中元素的數量和存儲空間的分配情況。下面是關于?vector?容器容量和大小的詳細介紹：

大小（size）：

容器的大小是指容器中當前實際存儲的元素數量。
可以通過?size()?成員函數獲取容器的大小。
當我們向容器中添加元素時，大小會增加；當我們從容器中刪除元素時，大小會減少。
例如，如果一個?vector?容器中有 5 個元素，則其大小為 5。

容量（capacity）：

容器的容量是指在不分配新的存儲空間的情況下，容器可以容納的元素數量。
可以通過?capacity()?成員函數獲取容器的容量。
容器的容量總是大于或等于其大小。當容器的元素數量接近容量時，可能需要重新分配內存空間，以增加容器的容量。
容器的容量通常會隨著元素的動態添加而增加，并可能會超過實際存儲的元素數量。

空間操作細節：

當容器的大小超過容量時，容器會自動分配更大的存儲空間，并將原有元素拷貝到新的存儲空間中。
這種情況下，容器的容量會增加，但元素本身的數量沒有改變。
當容器的大小小于等于容量時，并不會釋放多余的存儲空間。但可以使用?shrink_to_fit()?函數來要求容器釋放多余的存儲空間，使容量等于大小。

? ? ? ?總之，vector?容器的大小和容量是在動態管理元素存儲空間時非常重要的概念，了解它們能夠幫助我們更好地理解容器內部的存儲機制，并合理地使用容器的操作函數。

???????下面給出具體代碼分析應用過程：這段代碼展示了容器構造函數的使用以及容器的基本操作，以下是簡要的代碼分析：

頭文件包含：
- 代碼包含了?<iostream>?頭文件用于輸入輸出操作。
- 使用了?using namespace std;?聲明，以便在代碼中直接使用?cout?和?endl?等標準庫中的元素。
- 引入了?<vector>?頭文件，以使用?vector?容器。
函數定義：
- 定義了一個名為?printVector?的函數，用于輸出?vector<int>?容器中的元素。
測試函數?test01：
- 創建一個空的?vector<int>?容器?v1，并通過循環將 0 到 9 的整數依次添加到容器中。
- 調用?printVector?函數輸出?v1?容器的內容。
- 使用?empty()?函數檢查容器是否為空，如果為空則輸出 “v1為空”，否則輸出容器的容量和大小，以及繼續執行后續語句。
- 調用?resize(15)?函數重新指定容器?v1?的大小為 15，這會導致容器的容量自動擴大，由于原先只有 10 個元素，額外的 5 個位置會用默認值（0）填充。
- 再次調用?printVector?函數輸出修改后的?v1?容器的內容，并輸出當前容器的容量。
main?函數：
- 在?main?函數中調用?test01?函數以執行測試。
- 使用?system("pause");?使程序暫停，防止窗口一閃而過。

? ? ? ?總體來說，這段代碼展示了使用?vector?容器的構造函數、基本操作（如輸出容器內容、檢查容器是否為空、獲取容器的容量和大小，重新指定容器大小等）。通過這些操作，我們可以更好地理解?vector?容器的特性和使用方法。

#include<iostream>
using namespace std;
#include <vector>// 容器構造函數 void printVector(vector<int> & v)   // 這里既然需要輸出容器，必然要傳入一個定義的容器變量，采用引用方式
{for (vector<int>::iterator it = v.begin(); it != v.end(); it++){cout << *it << " ";}cout << endl;}void test01()
{vector<int>v1;   // 1、默認構造函數 for (int i = 0; i < 10; i++){v1.push_back(i);}// 調用一個輸出容器的函數printVector(v1);   // 這里函數以引用方式做傳入的參數，并且參數類型是vector<int>容器類型if (v1.empty())   // 為真，代表容器為空{cout << "v1為空" << endl;}else{cout << "v1不為空" << endl;cout << "v1的容量" << v1.capacity() << endl;   // 容量一定大于等于插入的參數個數cout << "v1的大小" << v1.size() << endl;}// 重新指定容器大小v1.resize(15);printVector(v1);// 這里重新指定了size大小，容器容量回自動擴大，由于v1本來只有10個數值，另外5個參數默認為0cout << "v1此時的容量" << v1.capacity() << endl;}int main() {test01();system("pause");return 0;
}

???????實例結果如下圖所示：??

05-Vector容器插入和刪除

? ? 在 C++ STL 中，vector?容器提供了豐富的方法用于插入和刪除元素，下面是關于?vector?容器插入和刪除操作的詳細介紹：

插入操作：
push_back：?在容器的末尾插入一個元素。
vector<int> v = {1, 2, 3};
v.push_back(4); // 將元素 4 插入到容器末尾后，容器變為 {1, 2, 3, 4}
insert：?在指定位置插入元素或一段元素。
vector<int> v = {1, 2, 3, 4, 5};
v.insert(v.begin() + 2, 10); // 在第三個位置（索引為2）插入元素 10，容器變為 {1, 2, 10, 3, 4, 5}
v.insert(v.begin() + 3, {20, 30, 40}); // 在第四個位置插入元素 20, 30, 40，容器變為 {1, 2, 10, 20, 30, 40, 3, 4, 5}
刪除操作：
pop_back：?刪除容器末尾的元素。
vector<int> v = {1, 2, 3, 4, 5};
v.pop_back(); // 刪除容器末尾的元素，容器變為 {1, 2, 3, 4}
erase：?刪除指定位置或指定范圍內的元素。
vector<int> v = {1, 2, 3, 4, 5};
v.erase(v.begin() + 2); // 刪除第三個位置的元素，容器變為 {1, 2, 4, 5}
v.erase(v.begin() + 1, v.begin() + 4); // 刪除從第二個位置至第四個位置的元素，容器變為 {1, 5}
clear：?清空容器中的所有元素，使容器為空。
vector<int> v = {1, 2, 3, 4, 5};
v.clear(); // 清空容器中的所有元素，容器變為空
注意事項：

插入和刪除元素可能會導致迭代器失效，要特別注意在循環中插入或刪除元素時的迭代器處理。
刪除元素后，后續的元素會向前移動，因此要注意索引的變化。
? ? ? ?通過上述詳細介紹，你可以深入了解?vector?容器在實際編程中如何進行元素的插入和刪除操作，合理地利用這些操作可以使代碼更加靈活和高效。

???????下面給出具體代碼分析應用過程：? 這段代碼主要演示了關于?vector?容器的插入和刪除操作，以下是代碼的簡要分析：

頭文件包含和函數定義：
- 引入了?<iostream>?和?<vector>?頭文件，用于輸入輸出以及使用?vector?容器。
- 定義了一個用于輸出?vector<int>?容器元素的函數?printVector。
test01?函數：
- 創建一個空的?vector<int>?容器?v1。
- 使用?push_back?方法向容器尾部依次插入元素 10, 20, 30, 40, 50。
- 調用?printVector?函數輸出容器?v1?中的所有元素。
- 使用?pop_back?方法刪除容器尾部的元素，此處刪除了元素 50。
- 使用?insert?方法在容器的起始位置插入元素 100。
- 使用?erase?方法刪除容器的第一個元素。
- 注釋掉了?v1.clear()?方法，該方法用于清空容器中的所有元素，但在此處被注釋掉未執行。
main?函數：
- 在?main?函數中調用?test01?函數以執行測試。
- 使用?system("pause");?使程序暫停，防止窗口一閃而過。
運行結果：
- 程序執行后，將依次輸出?v1?容器中的元素，每次操作后的容器內容都會被打印出來。

? ? ? ? 通過這段代碼的執行，你可以了解?vector?容器的插入和刪除操作的具體細節，并體會這些操作對容器中元素的影響。如果想要繼續學習和探究，可以嘗試更多不同方式的插入和刪除操作，以加深對?vector?容器的理解。

#include<iostream>
using namespace std;
#include <vector>/*  push_back(ele); //尾部插入元素elepop_back(); //刪除最后一個元素insert(const_iterator pos, ele); //迭代器指向位置pos插入元素eleinsert(const_iterator pos, int count,ele); //迭代器指向位置pos插入count個元素eleerase(const_iterator pos); //刪除迭代器指向的元素erase(const_iterator start, const_iterator end); //刪除迭代器從start到end之間的元素clear(); //刪除容器中所有元素
*/
void printVector(vector<int> & v)   // 這里既然需要輸出容器，必然要傳入一個定義的容器變量，采用引用方式
{for (vector<int>::iterator it = v.begin(); it != v.end(); it++){cout << *it << " ";}cout << endl;}void test01()
{vector<int>v1;   // 1、默認構造函數 // 1、插入數據，尾插法v1.push_back(10);v1.push_back(20);v1.push_back(30);v1.push_back(40);v1.push_back(50);// 調用一個輸出容器的函數printVector(v1);   // 這里函數以引用方式做傳入的參數，并且參數類型是vector<int>容器類型// 2、尾刪v1.pop_back();   // 這里直接默認刪除尾部數據printVector(v1);// 3、插入v1.insert(v1.begin(), 100);  // 這里第一個參數必須插入一個迭代器，第二參數是需要插入的數值printVector(v1);// 4、刪除v1.erase(v1.begin());
//	v1.clear();// 清空操作printVector(v1);}int main() {test01();system("pause");return 0;
}

???????實例結果如下圖所示：??

06-Vector容器數據存取

? ? 在 C++ 的標準模板庫（STL）中，vector?容器提供了多種方法用于數據的存取，下面是關于?vector?容器數據存取操作的詳細介紹：

數據存取：
使用下標?[]?運算符：

可以通過下標訪問?vector?容器中的元素。
vector<int> v = {10, 20, 30, 40, 50};
cout << v[1]; // 輸出第二個元素，即 20
at?方法：

類似于?[]?運算符，但提供了邊界檢查，并在索引超出范圍時拋出異常。
vector<int> v = {10, 20, 30, 40, 50};
cout << v.at(3); // 輸出第四個元素，即 40
使用迭代器：

可以使用迭代器訪問?vector?容器中的元素，包括正向迭代器和反向迭代器。
vector<int> v = {10, 20, 30, 40, 50};
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {cout << *it << " ";
}
front?和?back?方法：

front?方法返回容器中第一個元素的引用，back?方法返回容器中最后一個元素的引用。
vector<int> v = {10, 20, 30, 40, 50};
cout << v.front(); // 輸出第一個元素，即 10
cout << v.back(); // 輸出最后一個元素，即 50
data?方法：

返回指向存儲容器內所有元素的數組的指針，常用于與 C 風格的函數進行交互。
vector<int> v = {10, 20, 30, 40, 50};
int *ptr = v.data();
? ? ? ?通過以上詳細介紹，你可以更全面地了解如何使用?vector?容器進行數據的存取操作。合理地選擇不同的方法可以方便地訪問和操作?vector?容器中的元素，提高代碼效率和可讀性。

???????下面給出具體代碼分析應用過程：這段代碼主要演示了使用?vector?容器存儲一組整數數據，并通過不同方式進行數據的訪問操作。以下是對代碼的簡要分析：

頭文件包含和命名空間：
- 引入了?<iostream>?頭文件用于輸入輸出，以及?<vector>?頭文件用于使用?vector?容器。
- 使用?using namespace std;?表示使用?std?命名空間。
test01?函數：
- 創建一個空的?vector<int>?容器?v1。
- 使用?push_back?方法向容器中插入整數數據 0 到 9。
- 通過?[]?運算符訪問容器中的元素，依次輸出所有元素。
- 通過?at?方法訪問容器中的元素，同樣依次輸出所有元素。
- 在每種方式下，使用?for?循環遍歷容器中的元素并輸出。
main?函數：
- main?函數調用?test01?函數來執行測試。
運行結果：
- 程序執行后，將會輸出兩次相同的整數序列，分別通過?[]?運算符和?at?方法訪問?vector?容器中的元素。
補充說明：
- 通過?[]?運算符和?at?方法都可以實現對?vector?容器元素的訪問，但使用?at?方法能夠進行邊界檢查，當索引越界時會拋出異常。
- 在這段代碼中，循環遍歷容器并輸出元素是比較常見的操作，可以方便地查看容器中的數據內容。

? ? ? ?通過這段代碼的簡要分析，你可以更加熟悉如何在 C++ 中使用?vector?容器存儲數據并進行訪問操作，同時了解了如何通過?[]?運算符和?at?方法來訪問容器中的元素。這些基本操作對于處理容器數據是非常重要的，希望這樣的分析對你有所幫助。

#include<iostream>
using namespace std;
#include <vector>void test01()
{vector<int>v1;   // 1、默認構造函數 for (int i = 0; i < 10; i++){v1.push_back(i);}// 可以使用[]方式訪問for (int i = 0; i < v1.size();i++){cout << v1[i] << " ";}cout << endl;// 使用at方式for (int i = 0; i < v1.size(); i++){cout << v1.at(i) << " ";}cout << endl;}int main() {test01();system("pause");return 0;
}

????????實例結果如下圖所示：???

07-Vector互換容器

? ? 在 C++ STL 中，vector?容器提供了?swap?方法用于交換兩個容器的內容，實現容器之間的互換操作。下面是關于?vector?容器互換容器內容的詳細介紹：

swap?方法：
swap?方法：

swap?方法可以交換兩個容器的所有元素，實現容器內容的互換操作。
語法：void swap(vector& x) noexcept;，其中?x?是另一個?vector?容器。
注意：交換后，原本的容器會變為空，另一個容器則包含原本容器中的所有元素。
示例代碼：
vector<int> v1 = {1, 2, 3, 4};
vector<int> v2 = {5, 6, 7};v1.swap(v2);// 現在 v1 包含 {5, 6, 7}，v2 變為空
注意事項：

swap?不會進行元素的復制或移動，而是直接交換指向元素的內部指針。
交換操作對于大容器的性能開銷較小，適合用于交換大量數據的情況。

與其他容器的互換：

除了兩個相同類型的?vector?容器之間可以互換外，不同類型的容器也可以通過?swap?方法進行互換。
例如，vector<int>?與?vector<double>?之間的互換也是可能的。
? ? ? ?通過使用?swap?方法，可以方便快速地交換兩個?vector?容器的所有元素，而無需復制或移動元素，提高了程序的效率和性能。這對于需要頻繁交換大量數據的情況特別有用，讓程序更加高效。希望這個詳細介紹對你有所幫助。

???????下面給出具體代碼分析應用過程：這段代碼主要演示了使用?vector?容器的?swap?方法來交換容器內容，并展示了通過巧妙利用?swap?方法來收縮內存空間的用法。以下是對代碼的簡要分析：

頭文件包含和命名空間：
- 引入了?<iostream>?頭文件用于輸入輸出，以及?<vector>?頭文件用于使用?vector?容器。
- 使用?using namespace std;?表示使用?std?命名空間。
printVector?函數：
- 定義了一個函數?printVector，用于打印傳入的?vector?容器中的所有元素。
test01?函數：
- 創建兩個?vector<int>?容器?v1?和?v2，分別存儲遞增和遞減的整數序列。
- 打印輸出兩個容器的元素。
- 使用?swap?方法交換?v1?和?v2?的內容。
- 再次打印輸出兩個容器的元素，展示交換后的結果。
test02?函數：
- 創建一個?vector<int>?容器?v，存儲從 0 到 99999 的整數序列。
- 打印輸出容器的容量和大小。
- 使用?resize?方法將容器大小重新指定為 3，但容量沒有改變。
- 利用?swap?方法來收縮內存空間，將匿名對象和原容器進行交換，實現收縮空間的效果。
- 最后打印輸出容器的容量和大小，展示內存空間被收縮的效果。
運行結果：
- 程序執行后，會輸出各個階段的容器內容、容量和大小信息，展示了?swap?方法交換容器內容和收縮內存空間的效果。

? ? ? ?通過這段代碼的簡要分析，你可以了解到如何使用?swap?方法來交換兩個容器的內容，并學習了一種利用?swap?方法來收縮?vector?容器內存空間的技巧。這種技巧能夠避免浪費過多內存空間，提高程序的效率。希望這個分析對你有所幫助。

#include<iostream>
using namespace std;
#include <vector>void printVector(vector<int> & v)
{for (vector<int>::iterator it = v.begin(); it != v.end();it++){cout << *it <<" ";}cout << endl;
}
void test01()
{vector<int>v1;   // 1、默認構造函數 for (int i = 0; i < 10; i++){v1.push_back(i);}cout << "交換前" << endl;printVector(v1);vector<int>v2;   // 1、默認構造函數 for (int i = 10; i > 0; i--){v2.push_back(i);}printVector(v2);cout << "交換后" << endl;v1.swap(v2);printVector(v1);printVector(v2);}// 實際用途
// 巧用swap交換函數可以收縮內存空間
void test02()
{vector<int>v;for (int i = 0; i < 100000;i++){v.push_back(i);}cout << "v的容量" << v.capacity() << endl;   // 138255cout << "v的大小" << v.size() << endl;       // 100000v.resize(3);   // 重新指定大小  ，容量并沒有改變，很容易浪費空間cout << "v的容量" << v.capacity() << endl;    // 138255cout << "v的大小" << v.size() << endl;        // 3// 巧用swap交換函數可以收縮內存空間vector<int>(v).swap(v);    // vector<int>(v)匿名對象的內存，在執行完畢后，將被自動釋放cout << "v的容量" << v.capacity() << endl;    // 3cout << "v的大小" << v.size() << endl;        // 3}int main() {test02();system("pause");return 0;
}

? ? ? ? 實例運行結果如下圖所示：

總結

? ? 在 C++ STL 中，vector?容器是一個非常常用的動態數組容器，提供了靈活的數組功能。以下是關于?vector?容器的總結：

特點：

動態數組：

vector?是一個動態數組容器，可以根據需要動態增長或縮減其大小。

連續存儲：

vector?中的元素在內存中是連續存儲的，因此支持高效的隨機訪問。

大小可變：

可以通過?push_back?方法向尾部添加元素，也可以通過?pop_back?方法刪除尾部元素。

下標訪問：

可以使用下標運算符?[]?或?at?方法來訪問容器中的元素。

尾部插入、刪除高效：

在尾部插入或刪除元素的時間復雜度為常數時間，即?O(1)。

插入、刪除中間元素效率低：

在中間位置插入或刪除元素的時間復雜度為線性時間，即?O(n)，因為需要移動元素。

常用操作：

構造與賦值：

支持多種構造方式，如默認構造、指定大小和初始值構造等。
可以使用?assign?方法進行賦值操作。

訪問元素：

提供了?[]?運算符、at?方法、front?和?back?方法等訪問元素的方式。

插入與刪除：

提供了?push_back、pop_back、insert、erase?等方法用于插入和刪除元素。

容量操作：

可以使用?size?方法獲取容器中元素的數量，使用?capacity?方法獲取容器的容量。
支持?resize?方法調整容器的大小，以及?reserve?方法預留容量。

交換容器：

可以使用?swap?方法交換兩個?vector?容器的內容，用于快速交換大量數據或收縮內存空間。

? ?vector?容器是 C++ 中常用的動態數組容器，具有靈活性和高效性。它支持動態增長和縮減、高效的尾部插入和刪除操作，以及隨機訪問元素等功能。同時，通過?swap?方法可以方便地交換容器內容，用于優化內存使用。在 C++ 編程中，vector?是處理動態數組數據的首選容器之一。