【C++26】パックインデックス深掘り — 制約・エッジケースと MSVC で使えない理由

// パックインデックスの基本形（式パックの索引）
#include <cstdio>

template <typename... Ts>
auto first(Ts... ts) {

    return ts...[0];
}

template <typename... Ts>
auto last(Ts... ts) {

    return ts...[sizeof...(ts) - 1];
}

int main() {

    std::printf("first=%d last=%d\n", first(1, 2, 3, 4, 5), last(1, 2, 3, 4, 5));
}

// 実行結果
// first=1 last=5

// パックインデックスの基本形（式パックの索引）
#include <cstdio>

template <typename... Ts>
auto first(Ts... ts) {

    return ts...[0];
}

template <typename... Ts>
auto last(Ts... ts) {

    return ts...[sizeof...(ts) - 1];
}

int main() {

    std::printf("first=%d last=%d\n", first(1, 2, 3, 4, 5), last(1, 2, 3, 4, 5));
    std::printf("__cpp_pack_indexing=%ldL\n", static_cast<long>(__cpp_pack_indexing));
}

// 実行結果
// first=1 last=5
// __cpp_pack_indexing=202311L

// 型パックの索引と decltype
#include <cstdio>
#include <string>
#include <type_traits>
#include <utility>

template <std::size_t I, typename... Ts>
using nth_type_t = Ts...[I];

template <std::size_t I, typename... Ts>
constexpr decltype(auto) get_nth(Ts&&... vs) {

    return std::forward<Ts...[I]>(vs...[I]);
}

int main() {

    using T0 = nth_type_t<0, int, double, std::string>;
    using T2 = nth_type_t<2, int, double, std::string>;
    static_assert(std::is_same_v<T0, int>);
    static_assert(std::is_same_v<T2, std::string>);

    std::string s = "hello";
    auto&& r = get_nth<2>(1, 2.5, s);
    static_assert(std::is_same_v<decltype(r), std::string&>);

}

// 実行結果
// type_pack ok, kind=std::string

// インデックスパックでの展開（並べ替えと繰り返し）
#include <cstdio>
#include <tuple>

template <std::size_t... Is, typename... Ts>
constexpr auto select(Ts&&... vs) {

    return std::make_tuple(vs...[Is]...);
}

int main() {

    constexpr auto reversed = select<2, 1, 0>(10, 20, 30);
    static_assert(reversed == std::tuple{30, 20, 10});

    constexpr auto repeated = select<1, 1, 0, 0>(10, 20, 30);
    static_assert(repeated == std::tuple{20, 20, 10, 10});

    std::printf("reversed=(%d,%d,%d) repeated=(%d,%d,%d,%d)\n",
                std::get<0>(reversed), std::get<1>(reversed), std::get<2>(reversed),
                std::get<0>(repeated), std::get<1>(repeated), std::get<2>(repeated),
                std::get<3>(repeated));
}

// 実行結果
// reversed=(30,20,10) repeated=(20,20,10,10)

// 制約1: 添字は定数式でなければならない
#include <cstdio>

template <typename... Ts>
auto at(std::size_t i, Ts... ts) {

    return ts...[i];
}

int main() {

    std::printf("%d\n", at(1, 10, 20, 30));
}

// 実行結果（g++ -std=c++26）
// error: 'i' is not a constant expression
// error: 'i' is not a constant expression [-Wtemplate-body]
// error: pack index is not an integral constant

// 制約2: 添字はパックの範囲内でなければならない
#include <cstdio>

template <typename... Ts>
auto at(Ts... ts) {

    return ts...[5];
}

int main() {

    std::printf("%d\n", at(10, 20, 30));
}

// 実行結果（g++ -std=c++26）
// error: pack index '5' is out of range for pack of length '3'

// 制約3: 空のパックは索引できない
#include <cstdio>

template <typename... Ts>
auto first_or_zero(Ts... ts) {

    return ts...[0];
}

int main() {

    std::printf("%d\n", first_or_zero());
}

// 実行結果（g++ -std=c++26）
// error: cannot index an empty pack

// 非推論コンテキストを作る
#include <cstdio>
#include <string_view>

template <typename...>
struct type_seq {};

template <typename... Ts>
auto f(Ts...[0] arg, type_seq<Ts...>) {

    return arg;
}

int main() {

    auto a = f("Hello", type_seq<std::string_view>{});
    std::printf("a.size()=%zu\n", a.size());
}

// 実行結果
// a.size()=5

// 旧文法: 添字付きの無名配列パラメータパック
template <typename... Ts>
void f(Ts... [1]);

int main() {

    f<char, bool>(nullptr, nullptr);
}

// 実行結果（g++ -std=c++26）
// error: no matching function for call to 'f<char, bool>(std::nullptr_t, std::nullptr_t)'
// error: candidate expects 1 argument, 2 provided

// 構造化束縛が導入したパックを、その場で索引する
#include <cstdio>
#include <tuple>

struct Point {

    int x;
    int y;
    int z;
};

template <std::size_t... Indices, typename Decomposable>
constexpr auto splice(Decomposable d) {

    auto [...elems] = d;

    return std::make_tuple(elems...[Indices]...);
}

int main() {

    constexpr Point p{.x = 1, .y = 4, .z = 3};
    constexpr auto s = splice<2, 1, 0>(p);
    static_assert(s == std::make_tuple(3, 4, 1));

    std::printf("splice<2,1,0>(1,4,3) = (%d,%d,%d)\n",
                std::get<0>(s), std::get<1>(s), std::get<2>(s));
}

// 実行結果
// splice<2,1,0>(1,4,3) = (3,4,1)

// 旧: 再帰で N 番目の型を取り出す（添字ごとに1段ずつ増える）
template <std::size_t I, typename T0, typename... Rest>
struct nth { using type = typename nth<I - 1, Rest...>::type; };

// 新: パックインデックス（1回で決まる）
template <std::size_t I, typename... Ts>
using nth = Ts...[I];

// 実行結果
// old: total=6472
// new: total=6472

// MSVC で同じコードが通るか
#include <cstdio>

template <typename... Ts>
auto first(Ts... ts) {

    return ts...[0];
}

int main() {

    std::printf("%d\n", first(1, 2, 3));
}

// 実行結果（cl /std:c++latest）
// error C2760: 構文エラー: '...' は予期しないエラーでした。';' が必要です
// error C3878: 構文エラー: 'jump-statement' の後に予期しないトークン '...' があります
// error C3520: 'ts': パラメーター パックはこのコンテキストで展開する必要があります