C++中的std::initializer_list使用解讀

更新時間：2023年07月14日 09:09:26 作者：一傾而盡

這篇文章主要介紹了C++中的std::initializer_list使用，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教

C++中的std::initializer_list

initializer_list是C++11提供的一種新類型，其定義于頭文件<initializer_list>中，此頭文件是工具庫的一部分，

<initializer_list>定義如下：

namespace std {
  template<class E> class initializer_list {
  public:
    using value_type = E;
    using reference = const E&;
    using const_reference = const E&;
    using size_type = size_t;
    using iterator = const E*;
    using const_iterator = const E*;
    constexpr initializer_list() noexcept;
    constexpr size_t size() const noexcept; // 元素數(shù)量
    constexpr const E* begin() const noexcept; // 首元素
    constexpr const E* end() const noexcept; // 末元素后一位置
  };
  // initializer_list 范圍訪問
  template<class E> constexpr const E* begin(initializer_list<E> il) noexcept;
  template<class E> constexpr const E* end(initializer_list<E> il) noexcept;
}

std::initializer_list 類型對象是一個訪問 const T 類型對象數(shù)組的輕量代理對象。

std::initializer_list 對象在這些時候自動構造：

用花括號初始化器列表列表初始化一個對象，其中對應構造函數(shù)接受一個std::initializer_list 參數(shù)
以花括號初始化器列表為賦值的右運算數(shù)，或函數(shù)調用參數(shù)，而對應的賦值運算符/函數(shù)接受 std::initializer_list 參數(shù)
綁定花括號初始化器列表到 auto ，包括在范圍 for 循環(huán)中

initializer_list 可由一對指針或指針與其長度實現(xiàn)。復制一個 std::initializer_list 不會復制其底層對象。

底層數(shù)組不保證在原始 initializer_list 對象的生存期結束后繼續(xù)存在。 std::initializer_list 的存儲是未指定的（即它可以是自動、臨時或靜態(tài)只讀內存，依賴場合）。 (C++14 前)

底層數(shù)組是 const T[N] 類型的臨時數(shù)組，其中每個元素都從原始初始化器列表的對應元素復制初始化（除非窄化轉換非法）。底層數(shù)組的生存期與任何其他臨時對象相同，除了從數(shù)組初始化 initializer_list 對象會延長數(shù)組的生存期，恰如綁定引用到臨時量（有例外，例如對于初始化非靜態(tài)類成員）。底層數(shù)組可以分配在只讀內存。 (C++14 起)

若聲明了 std::initializer_list 的顯式或偏特化則程序為病式。

1.成員類型

成員類型	定義
value_type	T
reference	const T&
const_reference	const T&
size_type	std_size_t
iterator	const T*
const_iterator	const T*

2.成員函數(shù)

構造函數(shù)

initializer_list() noexcept;	(C++11 起) (C++14 前)
constexpr initializer_list() noexcept;	(C++14 起)

#include <iostream>
#include <initializer_list>
int main(){
    std::initializer_list<int> empty_list;
    std::cout << "empty_list.size(): " << empty_list.size() << '\n';
    // 用列表初始化創(chuàng)建初始化器列表
    std::initializer_list<int> digits {1, 2, 3, 4, 5};
    std::cout << "digits.size(): " << digits.size() << '\n';
    // auto 的特殊規(guī)則表示‘ fraction '擁有類型
    // type std::initializer_list<double>
    auto fractions = {3.14159, 2.71828};
    std::cout << "fractions.size(): " << fractions.size() << '\n';
}

結果如下：

size ：返回initializer_list中元素數(shù)目
begin：返回指向首元素的指針
end：返回指向末尾元素后一位置的指針

3.非成員函數(shù)

std::begin(std::initializer_list) (C++11)	特化 std::begin
std::end(std::initializer_list)(C++11) 定義于頭文件	特化std::end
rbegin(std::initializer_list) (C++14)	特化std::rbegin
rend(std::initializer_list)(C++14)	特化std::rend

#include <iostream>
#include <vector>
#include <initializer_list>
template <class T>
struct S {
    std::vector<T> v;
    S(std::initializer_list<T> l) : v(l) {
         std::cout << "constructed with a " << l.size() << "-element list\n";
    }
    void append(std::initializer_list<T> l) {
        v.insert(v.end(), l.begin(), l.end());
    }
    std::pair<const T*, std::size_t> c_arr() const {
        return {&v[0], v.size()};  // 在 return 語句中復制列表初始化
                                   // 這不使用 std::initializer_list
    }
};
template <typename T>
void templated_fn(T) {}
int main(){
    S<int> s = {1, 2, 3, 4, 5}; // 復制初始化
    s.append({6, 7, 8});      // 函數(shù)調用中的列表初始化
    std::cout << "The vector size is now " << s.c_arr().second << " ints:\n";
    for (auto n : s.v)
        std::cout << n << ' ';
    std::cout << '\n';
    std::cout << "Range-for over brace-init-list: \n";
    for (int x : {-1, -2, -3}) // auto 的規(guī)則令此帶范圍 for 工作
        std::cout << x << ' ';
    std::cout << '\n';
    auto al = {10, 11, 12};   // auto 的特殊規(guī)則
    std::cout << "The list bound to auto has size() = " << al.size() << '\n';
//    templated_fn({1, 2, 3}); // 編譯錯誤！“ {1, 2, 3} ”不是表達式，
                             // 它無類型，故 T 無法推導
    templated_fn<std::initializer_list<int>>({1, 2, 3}); // OK
    templated_fn<std::vector<int>>({1, 2, 3});           // 也 OK
}

結果如下：