c++11-新增容器

一、本節內容

本節內容包括：

• 對標準庫的擴充: 新增容器
  • std::array
  • std::forward_list
  • std::unordered_set
  • std::unordered_map
  • std::tuple
    • 基本操作
    • 運行期索引
    • 合併與迭代

二、std::array 和 std::forward_list

std::array

看到這個容器的時候肯定會出現這樣的問題：

1. 爲什麼要引入 std::array 而不是直接使用 std::vector？
2. 已經有了傳統數組，爲什麼要用 std::array?

先回答第一個問題，std::vecotr 太強大了，以至於我們沒有必要爲了去敲碎一個雞蛋而用一個釘錘。使用 std::array 保存在棧內存中，相比堆內存中的 std::vector，我們就能夠靈活的訪問這裏面的元素，從而獲得更高的性能；同時正式由於其堆內存存儲的特性，有些時候我們還需要自己負責釋放這些資源。

而第二個問題就更加簡單，使用std::array能夠讓代碼變得更加現代，且封裝了一些操作函數，同時還能夠友好的使用標準庫中的容器算法等等，比如 std::sort。

std::array 會在編譯時創建一個固定大小的數組，std::array 不能夠被隱式的轉換成指針，使用 std::array 很簡單，只需指定其類型和大小即可：

std::array<int, 4> arr= {1,2,3,4};

int len = 4;
std::array<int, len> arr = {1,2,3,4}; // 非法, 數組大小參數必須是常量表達式

當我們開始用上了 std::array 時，難免會遇到要將其兼容 C 風格的接口，這裏有三種做法：

void foo(int *p, int len) {
    return;
}

std::array<int 4> arr = {1,2,3,4};

// C 風格接口傳參
// foo(arr, arr.size());           // 非法, 無法隱式轉換
foo(&arr[0], arr.size());
foo(arr.data(), arr.size());

// 使用 `std::sort`
std::sort(arr.begin(), arr.end());

std::forward_list

std::forward_list 是一個列表容器，使用方法和 std::list 基本類似，因此我們就不花費篇幅進行介紹了。

需要知道的是，和 std::list 的雙向鏈表的實現不同，std::forward_list 使用單向鏈表進行實現，提供了 O(1) 複雜度的元素插入，不支持快速隨機訪問（這也是鏈表的特點），也是標準庫容器中唯一一個不提供 size() 方法的容器。當不需要雙向迭代時，具有比 std::list 更高的空間利用率。

三、無序容器

我們已經熟知了傳統 C++ 中的有序容器 std::map/std::set，這些元素內部通過紅黑樹進行實現，插入和搜索的平均複雜度均爲 O(log(size))。在插入元素時候，會根據 < 操作符比較元素大小並判斷元素是否相同，並選擇合適的位置插入到容器中。當對這個容器中的元素進行遍歷時，輸出結果會按照 < 操作符的順序來逐個遍歷。

而無序容器中的元素是不進行排序的，內部通過 Hash 表實現，插入和搜索元素的平均複雜度爲 O(constant)，在不關心容器內部元素順序時，能夠獲得顯著的性能提升。

C++11 引入了兩組無序容器：std::unordered_map/std::unordered_multimap 和 std::unordered_set/std::unordered_multiset。

它們的用法和原有的 std::map/std::multimap/std::set/set::multiset 基本類似，由於這些容器我們已經很熟悉了，便不一一舉例，我們直接來比較一下std::map和std::multimap：

#include <iostream>
#include <string>
#include <unordered_map>
#include <map>

int main() {
    // 兩組結構按同樣的順序初始化
    std::unordered_map<int, std::string> u = {
        {1, "1"},
        {3, "3"},
        {2, "2"}
    };
    std::map<int, std::string> v = {
        {1, "1"},
        {3, "3"},
        {2, "2"}
    };

    // 分別對兩組結構進行遍歷
    std::cout << "std::unordered_map" << std::endl;
    for( const auto & n : u) 
        std::cout << "Key:[" << n.first << "] Value:[" << n.second << "]\n";

    std::cout << std::endl;
    std::cout << "std::map" << std::endl;
    for( const auto & n : v) 
        std::cout << "Key:[" << n.first << "] Value:[" << n.second << "]\n";
}

最終的輸出結果爲：

std::unordered_map
Key:[2] Value:[2]
Key:[3] Value:[3]
Key:[1] Value:[1]

std::map
Key:[1] Value:[1]
Key:[2] Value:[2]
Key:[3] Value:[3]

四、元組 std::tuple

瞭解過 Python 的程序員應該知道元組的概念，縱觀傳統 C++ 中的容器，除了 std::pair 外，似乎沒有現成的結構能夠用來存放不同類型的數據（通常我們會自己定義結構）。但 std::pair 的缺陷是顯而易見的，只能保存兩個元素。

元組基本操作

關於元組的使用有三個核心的函數：

1. std::make_tuple: 構造元組
2. std::get: 獲得元組某個位置的值
3. std::tie: 元組拆包

#include <tuple>
#include <iostream>

auto get_student(int id)
{
    // 返回類型被推斷爲 std::tuple<double, char, std::string>

    if (id == 0)
        return std::make_tuple(3.8, 'A', "張三");
    if (id == 1)
        return std::make_tuple(2.9, 'C', "李四");
    if (id == 2)
        return std::make_tuple(1.7, 'D', "王五");
    return std::make_tuple(0.0, 'D', "null");   
    // 如果只寫 0 會出現推斷錯誤, 編譯失敗
}

int main()
{
    auto student = get_student(0);
    std::cout << "ID: 0, "
    << "GPA: " << std::get<0>(student) << ", "
    << "成績: " << std::get<1>(student) << ", "
    << "姓名: " << std::get<2>(student) << '\n';

    double gpa;
    char grade;
    std::string name;

    // 元組進行拆包
    std::tie(gpa, grade, name) = get_student(1);
    std::cout << "ID: 1, "
    << "GPA: " << gpa << ", "
    << "成績: " << grade << ", "
    << "姓名: " << name << '\n';
}

std::get 除了使用常量獲取元組對象外，C++14 增加了使用類型來獲取元組中的對象：

std::tuple<std::string, double, double, int> t("123", 4.5, 6.7, 8);
std::cout << std::get<std::string>(t) << std::endl;
std::cout << std::get<double>(t) << std::endl;   // 非法, 引發編譯期錯誤
std::cout << std::get<3>(t) << std::endl;

運行期索引

如果你仔細思考一下可能就會發現上面代碼的問題，std::get<> 依賴一個編譯期的常量，所以下面的方式是不合法的：

int index = 1;
std::get<index>(t);

那麼要怎麼處理？答案是，標準庫做不到。這裏介紹一個使用 boost::variant 配合變長模板參數的黑魔法：

提示：使用 boost 只是暫時性的解決方案，variant 已在 C++17 中被納入標準庫 std::variant，見擴展主題它的討論。http://en.cppreference.com/w/cpp/utility/variant

#include <boost/variant.hpp>
template <size_t n, typename... T>
boost::variant<T...> _tuple_index(size_t i, const std::tuple<T...>& tpl) {
    if (i == n)
        return std::get<n>(tpl);
    else if (n == sizeof...(T) - 1)
        throw std::out_of_range("越界.");
    else
        return _tuple_index<(n < sizeof...(T)-1 ? n+1 : 0)>(i, tpl);
}
template <typename... T>
boost::variant<T...> tuple_index(size_t i, const std::tuple<T...>& tpl) {
    return _tuple_index<0>(i, tpl);
}

這樣我們就能：

int i = 1;
std::cout << tuple_index(i, t) << std::endl;

元組合並與遍歷

還有一個常見的需求就是合併兩個元組，這可以通過 std::tuple_cat 來實現：

auto new_tuple = std::tuple_cat(get_student(1), std::move(t));

馬上就能夠發現，應該如何快速遍歷一個元組？但是我們剛纔介紹瞭如何在運行期通過非常數索引一個 tuple 那麼遍歷就變得簡單了，首先我們需要知道一個元組的長度，可以：

template <typename T>
auto tuple_len(T &tpl) {
    return std::tuple_size<T>::value;
}

這樣就能夠對元組進行迭代了：

// 迭代
for(int i = 0; i != tuple_len(new_tuple); ++i)
    // 運行期索引
    std::cout << tuple_index(i, new_tuple) << std::endl;

總結

本節簡單介紹了 C++11/14 中新增的容器，它們的用法和傳統 C++ 中已有的容器類似，相對簡單，可以根據實際場景豐富的選擇需要使用的容器，從而獲得更好的性能。

std::tuple 雖然有效，但是標準庫提供的功能有限，沒辦法滿足運行期索引和迭代的需求，好在我們還有其他的方法可以自行實現。