序列式容器

序列容器是指在邏輯上以線性排列方式儲存給定型別元素的容器。

這些容器和陣列非常類似，都是在邏輯上連續的(但記憶體不一定是連續的)，與陣列不同的是，容器可以非常方便的動態管理，而不是固定元素大小。

 

std::vector

當你需要容器時，就找vector! 

-- Bjarne Stroustrup

std::vector 差不多是C++當中最常用的容器，它是一個模版類。你可以將它視作傳統陣列的動態功能增強版本，因此它的泛用性非常高。

當你以區域性變數形式建立並初始化 vector 時，物件本身是儲存於棧記憶體當中，但是它所儲存的元素卻是在堆記憶體當中連續的一塊空間，因此 std::vector 對於隨機訪問效率會非常高。

vector 的儲存是自動管理的，按需擴張收縮。 vector 通常佔用多於靜態陣列的空間，因為要分配更多記憶體以管理將來的增長。 vector 所用的方式不在每次插入元素時，而只在額外記憶體耗盡時重分配。分配的記憶體總量可用 capacity() 函式查詢。額外記憶體可通過對 shrink_to_fit() 的呼叫返回給系統。 (C++11 起)

重分配通常是效能上有開銷的操作。若元素數量已知，則 reserve() 函式可用於消除重分配。

-- 《C++ Reference》

 

標頭檔案：

#include <vector>

 

構造語法：

// 空初始化
std::vector<Type> name;

 
// 帶有預設集合
std::vector<Type> name{ value, value, ... };

// 預分配長度
std::vector<Type> name(num);

// 預分配長度與預設值
std::vector<Type> name(num, value);

 

成員函式：

名稱	說明
assign	清除當前vector並將指定的元素複製到該空vector。
at	返回對vector中指定位置的元素的引用。
back	返回對vector中最後一個元素的引用。
begin	返回該vector中起始位置的迭代器。
capacity	返回在不分配更多的記憶體的情況下vector可以包含的元素數。(當前記憶體空間)
cbegin	返回指向vector中起始位置的常量迭代器。(const修飾)
cend	返回末尾位置常量迭代器。(非末尾元素)(const修飾)
crbegin	返回一個指向vector中起始位置的常量反向迭代器。(const修飾)
crend	返回一個指向vector中末尾位置的常量反向迭代器。(const修飾)
clear	清除vector的所有元素。（但沒有回收記憶體）
data	返回指向vector中首個元素的指標。
emplace	將元素原位插入到指定位置之前。
emplace_back	將元素原位插入到指定位置之後。
empty	檢查vector是否為空。
end	返回指向vector末尾的迭代器。（非末尾元素）
erase	從指定位置刪除vector中的一個元素或一系列元素。
front	返回回vector中第一個元素的引用。
get_allocator	將物件返回到vector使用的 allocator 類。
insert	將一個元素或多個元素插入到vector指定位置。
max_size	返回vector的最大長度。
pop_back	刪除vector末尾處的元素。
push_back	在vector末尾處追加一個元素。
rbegin	返回起始位置的反向迭代器。
rend	返回末尾位置的反向迭代器。
reserve	重新分配vector的最小儲存長度。
resize	為vector指定新的大小。
shrink_to_fit	釋放冗餘容量(記憶體)。
size	返回vector中的元素數量。
swap	交換兩個vector的元素。

 

運算子：

名稱	說明
operator[]	返回對指定位置的vector元素的引用。
operator=	用另一個vector的副本替換該向量中的元素。

 

最簡單示例：

int main()
{
    std::vector<int> vec = { 0, 1, 2, 3, 4 };
    for (auto &i : vec)
    {
        std::cout << i << std::endl;
    }

    vec.reserve(10);

    vec.push_back(5);
    vec.push_back(6);
    vec.push_back(7);
    vec.push_back(8);
    vec.push_back(9);

    vec.erase(vec.begin() + 2, vec.end() - 3);

    for (auto& i : vec)
    {
        std::cout << i << std::endl;
    }

    vec.clear();
    std::vector<int>().swap(vec);

    return EXIT_SUCCESS;
}

擴充套件閱讀：

【Example】C++ Vector 記憶體預分配的良好習慣

【Example】C++ Vector 的記憶體強制回收

 

 

std::list

std::list 是一個模板類，即連結串列。它的特點是每個元素在邏輯上都以線性連續方式來儲存。

它的每個元素內部都有指向前元素及後元素的指標，每次插入與刪除都只需更改前後“鄰居”的指標，可以做到任何位置高效的插入與刪除。

但是，雖然在邏輯上是連續的，然而每個元素在記憶體當中並不是連續儲存的，因此 std::list 無法做到像 std::vector 那樣隨機讀寫。（它直接沒有 at 函式及 [] 過載）

此外 std::list 對異常的控制是，要麼操作成功，出現異常則不進行任何更改。

 

標頭檔案：

#include <list>

 

構造語法：

// 預設
std::list<Type> name;

// 預分配長度
std::list<Type> name(num);

// 預分配長度及預設值
std::list<Type> name(num, value);

// 從 initlist 建立
std::list<Type> name(initlist);

// 迭代器區間建立
std::list<Type> name(obj.begin(), obj.end());

 

成員函式：

名稱	說明
assign	清空當前list並將指定的元素複製到當前空list。
back	返回對list中最後一個元素的引用。
begin	返回list中指向起始位置的迭代器。
cbegin	返回list中起始的位置的常量迭代器。(const修飾)
cend	返回list中末尾的位置的常量迭代器。(const修飾)
clear	清空list。
crbegin	返回list中起始的常量反向迭代器。(const修飾)
crend	返回list中末尾的常量反向迭代器。(const修飾)
emplace	將元素原位插入到指定位置。
emplace_back	將元素原位插入到末尾位置。
emplace_front	將元素原位插入到起始位置。
empty	判斷list是否為空。
end	返回list中指向末尾的迭代器。
erase	從指定位置刪除list中的一個元素或一系列元素。
front	返回對list中第一個元素的引用。
get_allocator	返回用於構造list的 allocator 物件的一個副本。
insert	將一個、幾個或一系列元素插入list中的指定位置。
max_size	返回list的最大長度。
merge	合併兩個已排序list，合併前必須升序或其他指定順序排序。
pop_back	刪除最後元素。
pop_front	刪除首個元素。
push_back	從末尾追加元素。
push_front	從起始追加元素。
rbegin	返回起始位置的反向迭代器。
remove	移除滿足條件的元素。
remove_if	移除滿足謂詞條件的元素。
rend	返回list中末尾的反向迭代器。
resize	重新分配長度。
reverse	反轉list中元素的順序。
size	返回list中元素的數目。
sort	按升序或指定其他順序排列list中的元素。
splice	從另一個list中移動元素。
swap	交換兩個list的元素。
unique	刪除連續的重複元素。

 

運算子：

名稱	說明
operator=	用另一個list的副本替換當前list中的元素。

 

最簡單示例：

int main()
{
    std::list<int> list(10, 0);

    list.emplace_front(1);
    list.emplace_front(2);
    list.emplace_back(6);
    list.emplace_back(7);

    for (auto& i : list)
    {
        std::cout << i << std::endl;
    }
    std::cout << "------" << std::endl;

    list.sort();
    std::list<int> list_m{1, 2, 3, 4, 5};
    list.merge(list_m);

    for (auto& i : list)
    {
        std::cout << i << std::endl;
    }return EXIT_SUCCESS;
}

 

擴充套件閱讀：

std::forward_list 是單項鍊表，它的標頭檔案是：

#include <forward_list>

 

它的操作方式和 std::list 基本相同，但是，由於它是單向連結串列，所以它沒有反向迭代器。

也就意味著沒有 size() 函式，沒有 push_back()、pop_back()、emplace_back() 這些涉及反向操作的函式。

它的優勢是空間利用率比 std::list 更高，酌情使用。

它相對於 std::list 多了以下操作函式：

名稱	說明
before_begin	返回指向第一個元素之前的迭代器
cbefore_begin	返回指向第一個元素之前的常量迭代器
insert_after	在某個元素後插入新元素
emplace_after	在元素後原位構造元素
erase_after	擦除元素後的元素

 

 

std::deque

雙端佇列，是具有下標與邏輯相鄰順序的容器。它是 std::vector 與 std::list 相結合的方案，既可隨機訪問、也可高效雙端插入刪除。

std::vector 之所以隨機訪問效率高，是因為它在記憶體當中是連續的空間並且具有下標。

std::list 之所以插入刪除效率高，是因為它所進行插入與刪除操作時只需更改前後鄰居的連結節點指標。

 

先來看 std::vector 的記憶體邏輯：【Example】C++ Vector 記憶體預分配的良好習慣

std::vector 是始終保持每個元素在連續的一塊記憶體上，當 pushback 了新的元素後，如果冗餘記憶體空間不足，需要重新申請一塊新記憶體再將原有資料拷貝入新的記憶體塊並釋放舊記憶體塊。

而 std::deque 在面臨 pushback 了新元素且已有記憶體空間面臨不足情況時，則新申請一塊記憶體直接存入新資料，再對新舊記憶體塊進行連結。

因此，std::deque 本質是由多個連續記憶體塊組成，在一定程度上兼具了 std::vector 與 std::list 的優點，但卻無法單獨超越其中一者。

 

區塊，這很 Minecraft! /滑稽

-- ZhouFZ

 

除此之外，std::deque 還具有以下特點：

1，雙端都可以進行資料的增刪。

2，不支援記憶體預分配或其他控制手段，也不支援對容量進行手動修改。

3，deque 會釋放冗餘的記憶體區塊，時機取決於編譯器實現。

4，它的迭代器需要在不同記憶體區塊之間迭代，所以效能不如 std::vector 但優於 std::list 。

 

需要注意的問題：

迭代器非法化：指的是在 std::deque 邏輯上連續元素的頭尾與中間進行插入或刪除新的元素而導致的迭代器失效。

特別補充：迭代器失效情況也取決於編譯器實現，如果實際操作中存在任何可能原因而導致失效，請採取措施避免。

引發失效的情況：

操作	情況
在頭尾插入	可能導致迭代器失效(全部或部分)，但指標與引用仍然有效
在頭尾刪除	其他元素的迭代器不失效
中間插入或刪除操作	全部失效

 

具體原因：

std::deque 是一個同時管理著索引區塊與對應資料區塊的結構，它通過一個類似於 MAP 的 Key:Value 形式來記錄所擁有的記憶體區塊。

當出現頭尾插或者中間插操作時，如果當前所管理的資料記憶體區塊容量不足，而去開闢了新的資料記憶體區塊，自然索引就會增加。

如果儲存索引本身的區塊記憶體空間不足，就又要去開闢新的記憶體去儲存更改後的索引區塊，已有的迭代器自然就失效了，因為迭代器找不到自己所處資料區塊的原有索引在哪了。

（聽不懂沒事，多琢磨幾天。）

 

《C++ Reference》對迭代器非法化的補充

操作	被非法化
所有隻讀操作	決不
swap 、 std::swap	尾後迭代器可能被非法化（實現定義）
shrink_to_fit 、 clear 、 insert 、 emplace 、 push_front 、 push_back 、 emplace_front 、 emplace_back	始終
erase	若在起始擦除——僅被擦除元素 若在末尾擦除——僅被擦除元素和尾後迭代器 否則——非法化所有迭代器（包含尾後迭代器）。
resize	若新大小小於舊者：僅被擦除元素和尾後迭代器 若新大小大於舊者：非法化所有迭代器 否則——不非法化任何迭代器。
pop_front	僅有指向被擦除元素者
pop_back	僅有指向被擦除元素者和尾後迭代器

此節有仍少量不準確處，更多細節請檢視涉及單獨成員函式的頁面

非法化注意

• 從 deque 任一端插入時， insert 和 emplace 不會非法化引用。
• push_front 、 push_back 、 emplace_front 和 emplace_back 不會非法化任何到 deque 元素的引用。
• 從 deque 任一端擦除時， erase 、 pop_front 和 pop_back 不會非法化到未擦除元素的引用。
• 以較小的大小呼叫 resize 不會非法化任何到未擦除元素的引用。
• 以較大的大小呼叫 resize 不會非法化任何到 deque 元素的引用。

 

迴歸正題

標頭檔案：

#include <deque>

 

構造語法：

// 預設空
std::deque<Type> name;

// 拷貝構造
std::deque<Type> name(dequeobj);

// 預設分配長度及預設值
std::deque<Type> name(num, value);

// 迭代器區間
std::deque<Type> name(obj.begin(), obj.end());

 

成員函式：

名稱	說明
assign	清空當前deque並將指定的元素複製到當前空deque。
at	返回對deque中指定位置的元素的引用。
back	返回對deque中最後一個元素的引用。
begin	返回指向起始的迭代器。
cbegin	返回指向起始的常量迭代器。(const修飾)
cend	返回指向末尾的常量迭代器。(const修飾)
clear	清空 deque。
crbegin	返回指向起始的逆向常量迭代器。(const修飾)
crend	返回指向末尾的逆向常量迭代器。(const修飾)
emplace	將元素原位插入到指定位置。
emplace_back	將元素原位插入到末尾位置。
emplace_front	將元素原位插入到起始位置。
empty	檢查 deque 是否為空。
end	返回指向末尾的迭代器。
erase	從指定位置刪除一個或一系列元素。
front	返回第一個元素的引用。
get_allocator	返回用於構造 allocator 的 deque 物件的副本。
insert	將一個、多個或一系列元素插入到指定位置。
max_size	返回可容納的最大元素數。
pop_back	刪除末尾處的元素。
pop_front	刪除起始處的元素。
push_back	插入元素到末尾位置。
push_front	插入元素到起始位置。
rbegin	返回指向起始的逆向迭代器。
rend	返回指向末尾的逆向迭代器。
resize	手動改變大小。
shrink_to_fit	釋放未使用的記憶體。
size	返回當前長度。（元素數量）
swap	交換兩個deque。

 

運算子：

名稱	說明
operator[]	返回對指定位置的 deque 元素的引用。
operator=	將 deque 的元素替換為另一個 deque 的副本。

 

最簡單示例：

(注意看對迭代器的操作)

int main()
{
    std::deque<int> deque_d(10, 0);

    std::deque<int>::iterator it = deque_d.begin();
    it = deque_d.insert(it, 1);
    it = deque_d.insert(it, 2);
    it = deque_d.insert(it, 3);
    it = deque_d.insert(it, 4);

    std::deque<int>::iterator itf = std::find(deque_d.begin(), deque_d.end(), 3);
    itf = deque_d.emplace(itf, 5);
    itf = deque_d.emplace(itf, 6);
    itf = deque_d.emplace(itf, 7);

    for (auto &i : deque_d) {
        std::cout << i << std::endl;
    }

    return EXIT_SUCCESS;
}

 

 

std::array

標準庫陣列，本質一個模板類，是一個固定長度的容器，不可擴容。在現代C++中，主張使用 std::array 替代傳統樣式的陣列。

std::array 提供的功能也比 std::vector、std::list 更簡單。因為，它從設計上的目的，就是對傳統陣列進行現代化改造。

具體體現在：

1，它擁有和傳統陣列一樣的效能、可訪問性。

2，它具有傳統陣列所沒有的容器優點：可獲取大小、隨機訪問迭代器、支援賦值等。

所以，當你需要固定大小的陣列時，應首先考慮 std::array。

 

標頭檔案：

#include <array>

 

構造語法：

// 預設空
std::array<Type, SizeNum> name;

// 預設值情況下
std::array<Type, SizeNum> name{value, value...};
std::array<Type, SizeNum> name = {value, value...};

 

成員函式：

名稱	說明
array	構造一個數組物件。
at	訪問指定位置處的元素。
back	訪問最後一個元素。
begin	指定受控序列的開頭。
cbegin	返回一個隨機訪問常量迭代器，它指向陣列中的第一個元素。
cend	返回一個隨機訪問常量迭代器，它指向剛超過陣列末尾的位置。
crbegin	返回一個指向反向資料中第一個元素的常量迭代器。
crend	返回一個指向反向陣列末尾的常量迭代器。
data	獲取第一個元素的地址。
empty	測試元素是否存在。
end	指定受控序列的末尾。
fill	將所有元素替換為指定值。
front	訪問第一個元素。
max_size	對元素數進行計數。
rbegin	指定反向受控序列的開頭。
rend	指定反向受控序列的末尾。
size	對元素數進行計數。
swap	交換兩個容器的內容。

 

運算子：

運算子	說明
array::operator=	賦值替換陣列。
array::operator[]	訪問指定位置處的元素。

 

最簡單示例：

int main()
{
    std::array<int, 5> arry = {5, 4, 3, 2, 1};
    std::sort(arry.begin(), arry.end());

    for (auto &i : arry)
    {
        std::cout << i << std::endl;
    }
    std::cout << "-------------" << std::endl;

    arry[2] = 10;

    for (auto& i : arry)
    {
        std::cout << i << std::endl;
    }
    std::cout << "-------------" << std::endl;

    arry.fill(0);

    for (auto& i : arry)
    {
        std::cout << i << std::endl;
    }

    return EXIT_SUCCESS;
}

 

 

 

關聯式容器

與序列式容器不同的是，關聯式容器是採用鍵值對的方式即 Key : Value 對應的方式來儲存資料。

STL 所內建的關聯式容器主要使用紅黑樹來實現，容器內會自動根據 Key 來自動升序排序。

此外還有基於雜湊值的無序關聯式容器，請照貓畫虎使用即可。

 

名稱	標頭檔案	實現	鍵值對應	允許鍵重複	鍵排序
std::set	set	紅黑樹	Key = Value	No	升序
std::multiset	set	紅黑樹	Key = Value	Yes	升序
std::unordered_set	unordered_set	雜湊表	Key = Value	No	無
std::unordered_multiset	unordered_set	雜湊表	Key = Value	Yes	無
std::map	map	紅黑樹	Key : Value	No	升序
std::multimap	map	紅黑樹	Key : Value	Yes	升序
std::unordered_map	unordered_map	雜湊表	Key : Value	No	無
std::unordered_multimap	unordered_map	雜湊表	Key : Value	Yes	無

紅黑樹與雜湊表不同實現的關聯式容器區別：紅黑樹實現的關聯式容器遍歷效能更好，雜湊表實現的關聯式容器基於鍵的隨機訪問效能更好。

請記下表格當中的標頭檔案，下文當中不再贅述。 

 

Set

std::set 與 std::multiset 最顯著的特點就是鍵就是值，所以在 Set 當中的值不能直接修改，需要刪除舊值再重新建立新值 (即新建立鍵值，只是對於 set 來說值就是鍵而已)。

std::set 與 std::multiset 的區別是，std::set 不允許有重複值，std::multiset 則允許。兩者同樣都會根據鍵值大小進行升序排序。

 

構造語法：

// 預設
std::set<Type> name;
std::multiset<Type> sm1;

// 迭代器區間
std::set<Type> name(obj.begin(), obj.end());
std::multiset<Type> name(obj.begin(), obj.end());

// initlist
std::set<int> name{value, value, ...};
std::multiset<int> name{value, value, ...};

// 拷貝構造和移動構造略

// 自定義比較器(C++14)
struct Point { double x, y; };
struct PointCmp {
    bool operator()(const Point& lhs, const Point& rhs) const {
       return std::hypot(lhs.x, lhs.y) < std::hypot(rhs.x, rhs.y);
    }
};
std::set<Point, PointCmp> z = { {2, 5}, {3, 4}, {1, 1} };

 

成員函式：

名稱	說明
begin	返回指向起始的迭代器。
cbegin	返回指向起始的常量迭代器。(const修飾)
cend	返回指向末尾的常量迭代器。(const修飾)
clear	清除所有元素。
contains(c++20)	檢查是否存在指定鍵。僅限C++20。
count	返回匹配特定鍵的元素數量。
crbegin	返回指向起始的常量逆向迭代器。(const修飾)
crend	返回指向末尾的常量逆向迭代器。(const修飾)
emplace	原位插入元素。
emplace_hint	原位插入元素，且儘可能於 hint(迭代器) 前面位置。
empty	檢查是否為空。
end	返回指向末尾的迭代器。
equal_range	返回一對錶示範圍區間的迭代器，為匹配特定鍵的元素範圍。
erase	從指定位置移除一個元素或元素範圍，或者移除與指定鍵匹配的元素。
find	尋找帶有特定鍵的元素，並返回它所處位置的迭代器。
get_allocator	返回用於構造 allocator 的 set 物件的副本。
insert	將一個元素或元素範圍插入到set。
key_comp	返回set內用於比較排序物件(比較器)的副本。
lower_bound	返回指向首個不小於給定鍵的元素的迭代器。
max_size	返回set的最大長度。
rbegin	返回指向起始的逆向迭代器。
rend	返回指向末尾的逆向迭代器。
size	返回set中的元素數量。
swap	交換兩個set。
upper_bound	返回指向首個大於給定鍵的元素的迭代器。
value_comp	返回用於在value_type型別的物件中比較鍵的函式。

 

運算子：

名稱	說明
operator=	將一個集中的元素替換為另一個集的副本。

 

最簡單示例：

int main()
{
    std::set<int> s3{4, 3, 2, 1, 0};

    s3.emplace(5);
    s3.emplace(6);
    s3.emplace(7);
    s3.emplace(8);

    for (auto &i : s3) {
        std::cout << i << std::endl;
    }
    std::cout << "-------------" << std::endl;

    s3.erase(s3.find(5));
    s3.emplace(10);

    auto it = s3.equal_range(10);
    if (it.first == s3.end() || it.second == s3.end())
    {
        std::cout << "There are 10 in the set" << std::endl;
    }
 
    for (auto& i : s3) {
        std::cout << i << std::endl;
    }

    return EXIT_SUCCESS;
}

 

擴充套件閱讀：

std::unordered_set 與 std::unordered_multiset

基於雜湊表實現的無序 set 容器，擁有比紅黑樹所實現的版本更好的隨機訪問效能，但是遍歷效能弱於紅黑樹實現。

序列由雜湊函式弱排序，雜湊函式將此序列分割槽到稱為儲存桶的有序序列集中。 在每個儲存桶中，比較函式確定任何一對元素是否具有等效的排序。 每個元素同時用作排序鍵和值。 序列以允許查詢、插入和移除任意元素的方式表示，幷包含與序列中的元素數量無關的多個操作（常量時間），至少在所有儲存桶長度大致相等時如此。 在最壞情況下，當所有元素位於一個儲存桶中時，運算元量與序列中的元素數量成比例（線性時間）。 插入元素不會使任何 iterator 無效，刪除元素只會使指向已刪除元素的 iterator 失效。

-- Microsoft Docs

兩者相較於 std::set，新增了以下桶操作、雜湊策略函式：

名稱	說明
bucket_count	返回桶數量
max_bucket_count	返回桶最大數量
bucket_size	返回桶的大小
bucket	返回帶有特定鍵的桶
load_factor	返回每個桶的平均元素數量
max_load_factor	獲取或設定每個桶的最大元素數。
rehash	重新生成雜湊表，並且為指定數量的桶預留空間。
reserve	重新分配預留元素個數。
hash_function	返回用於儲存元素的雜湊函式物件。
key_eq	返回用於比較鍵相等性的函式物件。

 

 

Map

與 set 不同的是，map 系列是鍵值與值對應的形式，即 Key : Value 成對出現。基於紅黑樹的 map 會根據鍵的大小自動升序排序，基於雜湊表的則無序。

map 可以根據鍵的對映直接修改元素值。但是，鍵卻是常量無法修改，只能刪除已有的鍵值對再新增新的。

標準庫當中 map 系列分為 std::map 和 std::multimap，前者不允許鍵重複，後者則允許鍵重複。

 

構造語法：

// 預設空
std::map<KeyType, ValueType> name;

// initlist
std::map<KeyType, ValueType> name{ {Key, Value}, ...};

// 迭代器範圍
std::map<KeyType, ValueType> name(map.begin(), map.end());

// 拷貝構造和移動構造略

// 自定義比較struct
struct Comp
{
    int x, y;
    Comp(int v, int n) : x(v), y(n) {};
    bool operator()(const int& l, const int& r) const {
        return std::hypot(l, r) < std::hypot(x, y);
    };
};
std::map<int, string, Comp> m4(Comp(11, 22));

// 自定義比較lambda
int xx = 11;
int yy = 22;
auto compLambda = [&](const int &x, const int &y) {
    return std::hypot(x, y) < std::hypot(xx, yy);
};
std::map<int, string, decltype(compLambda)> m5(compLambda);

 

成員函式：

成員函式	說明
at	查詢具有指定鍵值的元素。(在std::multimap中不提供)
begin	返回一個迭代器，此迭代器指向Map起始位置。
cbegin	返回一個常量迭代器，此常量迭代器指向Map起始位置。(const修飾)
cend	返回一個常量迭代器，此常量迭代器指向Map末尾位置。(const修飾)
clear	清除所有元素。
contains(C++20)	檢查Map中是否有具有指定鍵的元素。(僅限C++20)
count	返回Map中其鍵與引數中指定的鍵匹配的元素數量。
crbegin	返回一個常量反向迭代器，此常量反向迭代器指向Map起始位置。(const修飾)
crend	返回一個常量反向迭代器，此常量反向迭代器指向Map末尾位置。(const修飾)
emplace	將原位構造的元素插入到Map中。
emplace_hint	將原位構造的元素插入到Map中，且儘可能於 hint(迭代器) 前面位置。
empty	判斷是否為空。
end	返回一個迭代器，此迭代器指向Map末尾位置。
equal_range	返回一對迭代器。 第一個迭代器指向Map中其鍵大於指定鍵的第一個元素。 第二個迭代器指向Map中其鍵等於或大於指定鍵的第一個元素。
erase	從指定位置移除Map中的元素或元素範圍。
find	尋找帶有特定鍵的元素，並返回它所處位置的迭代器。
get_allocator	返回用於構造 allocator 的 map 物件的副本。
insert	將一個或一系列元素插入到Map中的指定位置。
key_comp	返回Map內用於比較排序物件(比較器)的副本。
lower_bound	返回指向首個不小於給定鍵的元素的迭代器。
max_size	返回可容納的最大元素數。
rbegin	返回一個反向迭代器，此反向迭代器指向Map起始位置。
rend	返回一個反向迭代器，此反向迭代器指向Map末尾位置。
size	返回當前Map中的元素數量。
swap	交換兩個Map。
upper_bound	返回指向首個大於給定鍵的元素的迭代器。
value_comp	返回用於在value_type型別的物件中比較鍵的函式。

 

運算子：

名稱	說明
operator[]	將元素插入到具有指定鍵值的對映。(在std::multimap中不提供)
operator=	將一個對映中的元素替換為另一對映副本。

 

最簡單示例：

int main()
{
    std::map<int, string> mapObj{ {0, "ABC"}, {1, "DEF"}, {2, "GHI"}};
    for (auto &it : mapObj)
    {
        std::cout << "Key:" << it.first << " Value:" << it.second << std::endl;
    }
    std::cout << "-------------" << std::endl;

    std::vector<std::pair<int, string>> vec{ std::make_pair(3, "OOO"), std::make_pair(4, "PPP"), std::make_pair(5, "QQQ") };
    mapObj.insert(vec.begin(), vec.end());
    
    for (auto& it : mapObj)
    {
        std::cout << "Key:" << it.first << " Value:" << it.second << std::endl;
    }
    std::cout << "-------------" << std::endl;

    auto it = mapObj.find(4);
    if (it != mapObj.end())
    {
        it->second = "***";
    }

    for (auto& it : mapObj)
    {
        std::cout << "Key:" << it.first << " Value:" << it.second << std::endl;
    }

    return EXIT_SUCCESS;
}

 

擴充套件閱讀：

std::unordered_map 與 std::unordered_multimap

兩個基於雜湊表實現的 Map，顧名思義一個不允許鍵重複，另一個則允許。

雜湊函式將此序列分割槽到稱為儲存桶的有序序列集中。 在每個儲存桶中，比較函式將確定任一元素對是否具有等效順序。 每個元素儲存兩個物件，包括一個排序鍵和一個值。 序列以允許查詢、插入和移除任意元素的方式表示，幷包含與序列中的元素數量無關的多個操作（常量時間），至少在所有儲存桶長度大致相等時如此。 在最壞情況下，當所有元素位於一個儲存桶中時，運算元量與序列中的元素數量成比例（線性時間）。 此外，插入元素不會使迭代器失效，移除元素僅會使指向已移除元素的迭代器失效。

-- Microsoft Docs

兩者相較於 std::map，新增了以下桶操作、雜湊策略函式：

名稱	說明
bucket_count	返回桶數量
max_bucket_count	返回桶最大數量
bucket_size	返回桶的大小
bucket	返回帶有特定鍵的桶
load_factor	返回每個桶的平均元素數量
max_load_factor	獲取或設定每個桶的最大元素數。
rehash	重新生成雜湊表，並且為指定數量的桶預留空間。
reserve	重新分配預留元素個數。
hash_function	返回用於儲存元素的雜湊函式物件。
key_eq	返回用於比較鍵相等性的函式物件。

 

 

std::pair 與 std::tuple

可以同時儲存不同資料型別的容器，它們兩個都有各自的優勢與最佳用途。

 

std::pair 

std:pair 是一個類模板，提供了一個單元儲存兩個不同型別資料的功能，但也僅限於儲存兩個資料。

但也正是它的優勢：拿它可以輕鬆高效的初始化 std::map。

注意：宣告 std::pair 時<>內的型別宣告必須和初始化時()內排列的資料型別相對應。 

 

標頭檔案：

#include <utility>

 

構造語法：

// 預設空
std::pair<Type1, Type2> name;

// 預設值
std::pair<Type1, Type2> name(Value1, Value2);

// make_pair
auto name3(std::make_pair<Type1, Type2>(Value1, Value2));

 

成員物件：

成員名	說明
first	Value1
second	Value2

 

成員函式：

名稱	說明
operator=	賦值
swap	交換

 

輔助類：

名稱	說明
std::tuple_size<std::pair>	獲得大小
std::tuple_element<std::pair>	獲得元素型別

 

最簡單示例：

int main()
{
    std::map<int, string> mapObj{ {0, "ABC"}, {1, "DEF"}, {2, "GHI"}};

    std::vector<std::pair<int, string>> vec{ std::make_pair(3, "OOO"), std::make_pair(4, "PPP"), std::make_pair(5, "QQQ") };
    mapObj.insert(vec.begin(), vec.end());

    mapObj.insert(std::make_pair(6, "GGG"));
    mapObj.insert(std::make_pair(7, "EEE"));
    
    for (auto& it : mapObj)
    {
        std::cout << "Key:" << it.first << " Value:" << it.second << std::endl;
    }
    return EXIT_SUCCESS;
}

 

 

 

std::tuple

元組，它是 std::pair 的擴充套件，是一個類模板。可以將多個不同型別的值彙集在一起，但它的長度只能是固定的。

此外，它還需要配合其標頭檔案內的幾個類外部函式來使用。

注意：

1，宣告 std::tuple 時 <> 內的型別宣告必須和初始化時()內相排列的資料型別對應。 

2，std::tuple 長度是固定的，長度由宣告時 <> 內的型別數量而定，此後便不可更改。

 

標頭檔案：

#include <tuple>

 

構造語法：

// 預設空
std::tuple<Type1, Type2, Type3, ...> name;

// 預設值
std::tuple<Type1, Type2, Type3, ...> name(Value1, Value2, Value3, ...);

// 使用 std::pair 構造
std::tuple<Type1, Type2> name(std::make_pair<Type1, Type2>(Value1, Value2));

// 使用 std::make_tuple 構造
std::tuple<Type1, Type2, Type3, ...> name(std::make_tuple(Value1, Value2, Value3, ...));

 

成員函式:

名稱	說明
operator=	賦值
swap	交換兩個tuple

 

非成員輔助函式：

名稱	說明
make_tuple	建立一個tuple物件，其型別根據各實參型別定義
tie	建立左值引用的tuple，或將 tuple 解包為獨立物件
forward_as_tuple	建立轉發引用的 tuple
tuple_cat	通過連線任意數量的元組來建立一個tuple
std::get(std::tuple)	元組式訪問指定的元素

輔助類：

名稱	說明
tuple_size	獲得大小
tuple_element	獲得元素型別
ignore	用 tie 解包 tuple 時用來跳過元素的佔位符
std::uses_allocator<std::tuple>	特化 std::uses_allocator 型別特徵

 

最簡單示例：

int main()
{
    std::tuple<int, string, float> t4(std::make_tuple(0, "str", 3.14));
    
    std::cout << std::get<0>(t4) << std::endl;
    std::cout << std::get<1>(t4) << std::endl;
    std::cout << std::get<2>(t4) << std::endl;

    // 批量拆包
    int i;
    string s;
    float f;

    std::tie(i, s, f) = t4;

    std::cout << i << std::endl;
    std::cout << s << std::endl;
    std::cout << f << std::endl;

    return EXIT_SUCCESS;
}

 

 

容器配接器

C + + 標準庫定義了三種類型的容器介面卡： stack 、 queue 和 priority_queue 。 每種介面卡都限制了一些基礎容器類的功能，以便對標準資料結構提供精確控制的介面。

• stack 類支援) 資料結構的後進先出 (後進先出。 可以在腦海中將其類比為一摞盤子。 元素（盤子）只能從堆疊頂部（基容器末尾的最後一個元素）插入、檢查或刪除。 僅訪問頂部元素的限制是使用 stack 類的原因。

• queue 類支援先進先出 (FIFO) 資料結構。 可以在腦海中將其類比為排隊等候銀行櫃員的人。 元素（人）可從行的後部新增，並且可以從行的前部刪除。 行的前部和後部都可以插入。 僅以這種方式訪問前端和後端元素的限制是使用 queue 類的原因。

• priority_queue類對其元素進行排序，以便最大的元素始終位於頂部位置。 它支援元素的插入以及頂部元素的檢查和刪除。 要記住的一個好方法是，人們將其按 age、身高或其他一些標準進行排列。

 

-- Microsoft Docs

 

C++ 標準庫當中提供了三種容器配接器，分別是 std::stack、std::queue、std::priority_queue。它們並不是容器，而是給予容器功能，比如棧與佇列。

首先先講兩個邏輯：

棧：先進後出

佇列：先進先出

配接器目的就是給予容器這些抽象的功能。

擴充套件閱讀自行百度：百度百科_棧(Stack) | 百度百科_佇列(queue)

 

 

std::stack

std::stack 類是容器介面卡，它給予程式設計師棧的功能——特別是 FILO （先進後出）資料結構。

該類模板表現為底層容器的包裝器——只提供特定函式集合。棧從被稱作棧頂的容器尾部推彈元素。

-- 《C++ Reference》

在不指定的情況下，std::stcak 預設基於 std::deque 實現。當然也可手動指定基於 std::vector 或者 std::list 實現。

由於棧本身屬於線性概念，所有它不能用於關聯式容器。

 

標頭檔案：

#include <stack>

 

構造語法：

// 預設
std::stack<Type> name;

// 指定底層容器
std::stack<Type, std::vector<Type>> name;
std::stack<Type, std::list<Type>> name;
std::stack<Type, std::deque<Type>> name;

// 預設值統一初始化
std::stack<Type> name({1, 2, 3});

// 根據其他容器
std::vector<Type> name({1, 2, 3});
std::stack<int, std::vector<Type>> name(vec);

std::list<Type> list({ 1, 2, 3 });
std::stack<Type, std::list<Type>> name(list);

std::deque<Type> deque({ 1, 2, 3 });
std::stack<Type, std::deque<Type>> name(deque);

 

成員函式：

名稱	說明
top	訪問棧頂元素
empty	判斷是否為空
size	返回當前元素個數
push	向棧頂推入元素
pop	推出(移除)棧頂元素
emplace	原位向棧頂推入元素
swap	交換兩個型別相同的棧

 

運算子：

名稱	說明
operator=	賦值

 

最簡單示例：

int main()
{
    std::stack<int, std::vector<int>> st({ 1, 2, 3 });

    st.push(4);
    st.push(4);
    st.push(4);

    st.top() = 5;

    while (!st.empty())
    {
        std::cout << st.top() << std::endl;
        st.pop();
    }

    return EXIT_SUCCESS;
}

 

 

 

std::queue

佇列可以給予容器先進先出的功能，就像核酸檢測排隊一樣先到的先做。

和 std::stack 有一個共同點，就是 std::queue 也是預設使用 std::deque 作為預設容器，也可基於 std::vector 和 std::list。

PS：std::queue 支援 std:set 構造，但不支援 std::map。

 

標頭檔案：

#include <queue>

 

構造語法：

// 預設
std::queue<Type> name;

// 指定底層容器
std::queue<Type, std::vector<Type>> name;
std::queue<Type, std::list<Type>> name;
std::queue<Type, std::deque<Type>> name;

// 預設值統一初始化
std::queue<Type> name({1, 2, 3});

// 根據其他容器
std::vector<Type> name({1, 2, 3});
std::queue<int, std::vector<Type>> name(vec);

std::list<Type> list({ 1, 2, 3 });
std::queue<Type, std::list<Type>> name(list);

std::deque<Type> deque({ 1, 2, 3 });
std::queue<Type, std::deque<Type>> name(deque);

 

成員函式：

 

名稱	說明
front	訪問首個元素
back	訪問末尾
empty	判斷是否為空
size	返回當前元素個數
push	向尾部推入元素
pop	移除首個元素
emplace	原位向尾部推入元素
swap	交換兩個型別相同的佇列

 

運算子：

名稱	說明
operator=	賦值

 

最簡單示例：

int main()
{
    std::queue<int> qu({ 1, 2, 3 });
    
    qu.push(9);
    qu.pop(); // del 1

    std::cout << "Front " << qu.front() << std::endl; // 2
    std::cout << "Back " << qu.back() << std::endl; // 9

    return EXIT_SUCCESS;
}

 

 

std::priority_queue

std::priority_queue  與 std::queue 完全不同，它是優先順序佇列，優先順序高的元素先出佇列，而並非先進入的元素。

預設情況下，std::priority_queue 會選擇值最大的元素作為最高優先順序。當然，也可以自定義值最小元素作為最高優先順序。

PS：和 std::queue 一樣，std::priority_queue 支援 std:set 構造，但不支援 std::map。

 

標頭檔案:

#include <queue>

 

 

構造語法：

// 預設
std::priority_queue<Type> name;

// 指定底層容器
std::priority_queue<Type, std::vector<Type>> name;
std::priority_queue<Type, std::list<Type>> name;
std::priority_queue<Type, std::deque<Type>> name;
std::priority_queue<Type, std::set<Type>> name;

// 自定義比較器
auto comp = [](const Type& v1, const Type& v2){
    return v1 > v2;
};
std::priority_queue<Type, std::vector<Type>, decltype(comp)> name(comp);

 

 

成員函式：

名稱	說明
top	訪問最大優先順序元素
empty	判斷是否為空
size	返回當前所容納的元素數量
push	推入元素並排序底層容器
emplace	原位推入元素並排序底層容器
pop	移除優先順序最大的元素
swap	交換兩個同類型priority_queue

 

運算子：

名稱	說明
operator=	賦值

 

最簡單示例：

int main()
{
    auto comp = [](const int& v1, const int& v2){
        return v1 > v2;
    };
    std::priority_queue<int, std::vector<int>, decltype(comp)> pri_qu(comp);

    pri_qu.push(3);
    pri_qu.push(8);
    pri_qu.push(6);
    pri_qu.push(1);
    pri_qu.push(7);
    pri_qu.push(5);
    pri_qu.push(9);
    pri_qu.push(2);
    pri_qu.push(4);

    while (!pri_qu.empty())
    {
        std::cout << pri_qu.top() << std::endl;
        pri_qu.pop();
    }

    return EXIT_SUCCESS;
}

 

 

 

AirChip

2022-04-08 02:22