包索引 （C++26 起）

 

C++

編譯器支援

自由（freestanding）與宿主（hosted）

語言

標準庫

標準庫標頭檔案

具名要求

特性測試宏 (C++20)

語言支援庫

概念庫 (C++20)

診斷庫

記憶體管理庫

超程式設計庫 (C++11)

通用工具庫

容器庫

迭代器庫

範圍庫 (C++20)

演算法庫

字串庫

文字處理庫

數值庫

日期和時間庫

輸入/輸出庫

檔案系統庫 (C++17)

併發支援庫 (C++11)

執行控制庫 (C++26)

技術規範

符號索引

外部庫

 

C++ 語言

通用主題
預處理器 註釋	關鍵詞 轉義序列
流程控制
條件執行語句
if	switch
迭代語句（迴圈）
for range-for （C++11）	while do-while
跳轉語句
continue - break	goto - return
函式
函式宣告
Lambda 函式表示式
inline 說明符
動態異常規範 (直到 C++17*)
noexcept 說明符 (C++11)
異常
throw 表示式 try 塊	catch 處理程式
名稱空間
名稱空間宣告	命名空間別名
型別
基本型別 列舉型別 函式型別	類/結構體型別 聯合型別
說明符
const/volatile decltype （C++11） auto （C++11）	constexpr （C++11） consteval （C++20） constinit （C++20）
儲存期說明符
初始化
預設初始化 值初始化 零初始化 複製初始化 直接初始化	聚合初始化 列表初始化 (C++11)   常量初始化 引用初始化

表示式
值類別 求值順序	運算子 運算子優先順序
替代表示
字面量
布林 - 整型 - 浮點型
字元 - 字串 - nullptr （C++11）
使用者定義 (C++11)
工具
屬性 (C++11)
型別
typedef 宣告
類型別名宣告 (C++11)
型別轉換
隱式轉換 static_cast const_cast	顯式轉換 dynamic_cast reinterpret_cast
記憶體分配
new 表示式	delete 表示式
類
類宣告 建構函式 this 指標	訪問說明符 friend 說明符
類特有的函式屬性
虛擬函式 override 說明符 (C++11)   final 說明符 (C++11)	explicit （C++11） static
特殊成員函式
預設建構函式 複製建構函式 移動建構函式 (C++11)	複製賦值 移動賦值 (C++11) 解構函式
模板
類模板 函式模板	模板特化 引數包 (C++11)
雜項
內聯彙編	C++ 歷史

 

宣告

概覽 宣告語法 宣告說明符序列 宣告符 衝突宣告 說明符 typedef inline virtual 函式說明符 explicit 函式說明符 friend constexpr （C++11） consteval （C++20） constinit （C++20） 儲存類說明符 翻譯單元區域性 (C++20) class/struct union enum decltype （C++11） auto （C++11） alignas （C++11） constvolatile 包索引說明符 (C++26)     細化型別說明符 屬性 (C++11)

宣告符 引用 指標 陣列 塊宣告 簡單宣告   →結構化繫結宣告 (C++17) 別名宣告 (C++11) 命名空間別名定義 using 宣告 using 指令 static_assert 宣告 (C++11) asm 宣告 不透明列舉宣告 (C++11) 其他宣告 名稱空間定義 函式宣告 類模板宣告 函式模板宣告 顯式模板例項化 (C++11) 顯式模板特化 連結規範 屬性宣告 (C++11) 空宣告

 

表示式

通用
值類別 求值順序 常量表達式 主表示式	Lambda 表示式 (C++11) Requires 表示式 (C++20) 包索引表示式 (C++26) 潛在求值表示式
字面量
整數字面量 浮點數字面量 布林字面量 字元字面量	轉義序列 字串字面量 空指標字面量 (C++11) 使用者定義字面量 (C++11)
運算子
賦值運算子 遞增和遞減 算術運算子 邏輯運算子 比較運算子 成員訪問運算子 其他運算子 new 表示式 delete 表示式 throw 表示式	alignof sizeof sizeof... （C++11） typeid noexcept （C++11） 摺疊表示式 (C++17) 運算子的替代表示 優先順序和結合性 運算子過載 預設比較 (C++20)
轉換
隱式轉換 顯式轉換 常用算術轉換     使用者定義轉換	const_cast static_cast dynamic_cast reinterpret_cast

 

模板

引數和實參

類模板

函式模板

類成員模板

變數模板 (C++14)

模板引數推導

類模板實參推導 （C++17）

顯式（完全）特化

部分特化

依賴名稱

包 （C++11）

sizeof... （C++11）

摺疊表示式 (C++17)

包索引 （C++26）

SFINAE

約束和概念 (C++20)

Requires 表示式 (C++20)

 

訪問指定索引處的包元素。

語法

id-expression ...[ expression ]	(1)
typedef-name ...[ expression ]	(2)

1) 包索引表示式

2) 包索引說明符

typedef-name	-	命名包的識別符號或簡單模板 ID
id-expression	-	命名包的id-expression
表示式	-	一個轉換後的常量表達式 I，型別為 std::size_t，指定為索引，其中 I 在包索引中某個包 P 的範圍 [​0​, sizeof...(P)) 內

解釋

包索引是未展開包後跟省略號和下標內索引的*包擴充套件*。包索引有兩種：包索引表示式和包索引說明符。

設 P 是一個非空包，包含 P0, P1, ..., Pn-1，且 I 是一個有效索引，則擴充套件 P...[I] 的例項化產生 P 的包元素 PI。

不允許使用非常量表達式索引 I 對包進行索引。

int runtime_idx();
 
void bar(auto... args)
{
    auto a = args...[0];
    const int n = 1;
    auto b = args...[n];
    int m = 2;
    auto c = args...[m]; // error: 'm' is not a constant expression
    auto d = args...[runtime_idx()]; // error: 'runtime_idx()' is not a constant expression
}

不能對模板模板引數包進行索引。

template <template <typename...> typename... Temps>
using A = Temps...[0]<>; // error: 'Temps' is a pack of template template parameters
 
template <template <typename...> typename... Temps>
using B = Temps<>...[0]; // error: 'Temps<>' doesn't denote pack name 
                         // although it is a simple-template-id

包索引表示式

id-expression ...[ expression ]

包索引表示式表示*id-expression*，即包元素 PI 的表示式。該id-expression應由以下宣告引入：

• 非型別模板引數包,
• 函式引數包,
• lambda init-capture 包，或
• 結構化繫結包.

template <std::size_t I, typename... Ts>
constexpr auto element_at(Ts... args)
{
    // 'args' introduced in function parameter pack declaration
    return args...[I];
}
 
static_assert(element_at<0>(3, 5, 9) == 3);
static_assert(element_at<2>(3, 5, 9) == 9);
static_assert(element_at<3>(3, 5, 9) == 4); // error:  out of bounds
static_assert(element_at<0>() == 1); // error: out of bounds, empty pack
 
template <std::size_t I, typename Tup>
constexpr auto structured_binding_element_at(Tup tup)
{
    auto [...elems] = tup;
    // 'elems' introduced in structured binding pack declaration
    return elems...[I];
}
 
struct A { bool a; int b; };
 
static_assert(structured_binding_element_at<0>(A {true, 4}) == true);
static_assert(structured_binding_element_at<1>(A {true, 4}) == 4);
 
// 'Vals' introduced in non-type template parameter pack declaration
template <std::size_t I, std::size_t... Vals>
constexpr std::size_t double_at = Vals...[I] * 2; // OK
 
template <std::size_t I, typename... Args>
constexpr auto foo(Args... args)
{
    return [...members = args](Args...[I] op)
    {
        // 'members' introduced in lambda init-capture pack
        return members...[I] + op;
    };
}
 
static_assert(foo<0>(4, "Hello", true)(5) == 9);
static_assert(foo<1>(3, std::string("C++"))("26") == "C++26");

不允許對除 id-expression 之外的複雜表示式包進行索引。

template <std::size_t I, auto... Vals>
constexpr auto identity_at = (Vals)...[I]; // error
// use 'Vals...[I]' instead
 
template <std::size_t I, std::size_t... Vals>
constexpr std::size_t triple_at = (Vals * 3)...[I]; // error
// use 'Vals...[I] * 3' instead
 
template <std::size_t I, typename... Args>
constexpr decltype(auto) get(Args&&... args) noexcept
{
    return std::forward<Args>(args)...[I]; // error
    // use 'std::forward<Args...[I]>(args...[I])' instead
}

將decltype應用於包索引表示式與將decltype應用於 id-expression 相同。

void f() 
{
    [](auto... args)
    {
        using T0 = decltype(args...[0]);   // 'T0' is 'double'
        using T1 = decltype((args...[0])); // 'T1' is 'double&'
    }(3.14);
}

包索引說明符

typedef-name ...[ expression ]

包索引說明符表示*計算型別說明符*，即包元素 PI 的型別。該typedef-name應由型別模板引數包的宣告引入。

template <typename... Ts>
using last_type_t = Ts...[sizeof...(Ts) - 1];
 
static_assert(std::is_same_v<last_type_t<>, int>); // error: out of bounds
static_assert(std::is_same_v<last_type_t<int>, int>);
static_assert(std::is_same_v<last_type_t<bool, char>, char>);
static_assert(std::is_same_v<last_type_t<float, int, bool*>, bool*>);

包索引說明符可以作為以下形式出現：

• 一個簡單型別說明符，
• 一個基類說明符，
• 一個巢狀名稱說明符，或
• 顯式解構函式呼叫的型別。

包索引說明符可用於函式或建構函式引數列表，以在模板引數推導中建立非推導上下文。

template <typename...>
struct type_seq {};
 
template <typename... Ts>
auto f(Ts...[0] arg, type_seq<Ts...>)
{
    return arg;
}
 
// OK: "Hello" is implicitly converted to 'std::string_view'
std::same_as<std::string_view> auto a = f("Hello", type_seq<std::string_view>{});
 
// Error: "Ok" is not convertible to 'int'
std::same_as<int> auto b = f("Ok", type_seq<int, const char*>{});

注意

在 C++26 之前，Ts...[N] 是宣告大小為 N 的未命名陣列的函式引數包的有效語法，其中引數型別會進一步調整為指標。從 C++26 開始，Ts...[1] 被解釋為包索引說明符，這將把下面的行為改為 #2。為了保留第一種行為，函式引數包必須命名，或手動調整為指標型別包。

template <typename... Ts>
void f(Ts... [1]);
 
template <typename... Ts>
void g(Ts... args[1]);
 
template <typename... Ts>
void h(Ts*...); // clearer but more permissive: Ts... can contain cv void or function types
 
void foo() 
{
    f<char, bool>(nullptr, nullptr);
    // behavior #1 (before C++26):
    //  calls void 'f<char, bool>(char*, bool*)' (aka 'f<char, bool>(char[1], bool[1])')
    // behavior #2 (since C++26): 
    //  error: supposedly called 'void f<char, bool>(bool)'
    //  but provided with 2 arguments instead of 1
 
    g<char, bool>(nullptr, nullptr);
    // calls 'g<char, bool>(char*, bool*)' (aka 'g<char, bool>(char[1], bool[1])')
 
    h<char, bool>(nullptr, nullptr);
    // calls 'h<char, bool>(char*, bool*)'
}

功能測試宏	值	標準	特性
__cpp_pack_indexing	202311L	（C++26）	包索引

示例

執行此程式碼

#include <tuple>
 
template <std::size_t... Indices, typename Decomposable>
constexpr auto splice(Decomposable d)
{
    auto [...elems] = d;
    return std::make_tuple(elems...[Indices]...);
}
 
struct Point
{
    int x;
    int y;
    int z;
};
 
int main() 
{
    constexpr Point p { .x = 1, .y = 4, .z = 3 };
    static_assert(splice<2, 1, 0>(p) == std::make_tuple(3, 4, 1));
    static_assert(splice<1, 1, 0, 0>(p) == std::make_tuple(4, 4, 1, 1));
}