能否使用变量而非常量作为索引调用std::get访问std::tuple元素？

不行，std::get的索引是模板参数，必须是编译期就能确定的常量表达式，普通运行时变量没法直接用在这里。

原因 #

C++模板是编译阶段实例化的，std::get<N>里的N得在编译时就确定——因为tuple的每个元素类型可能不一样，编译器需要提前知道要返回什么类型的值，这就要求索引必须是编译期常量。

替代方案 #

如果需要用运行时变量选择tuple元素，有几种标准库支持的实现方式：

1. 用std::apply遍历所有元素

适合需要处理tuple中每个元素的场景：

#include <iostream>
#include <string>
#include <tuple>
#include <utility>

int main() {
    auto t = std::make_tuple(1, "Foo", 3.14);
    std::apply([](auto&&... args) {
        std::cout << "(";
        // 折叠表达式遍历所有元素
        ((std::cout << args << ", "), ...);
        std::cout << "\b\b)\n"; // 移除末尾多余的逗号和空格
    }, t);
}

2. 结合std::variant和分支选择

如果要根据运行时索引获取单个元素，可以用std::variant统一不同元素的类型，再通过分支匹配索引：

#include <iostream>
#include <string>
#include <tuple>
#include <variant>
#include <stdexcept>

template<typename Tuple>
auto get_tuple_element(Tuple&& t, size_t index) {
    // 用variant包裹tuple所有元素的类型
    using VariantType = std::variant<
        std::decay_t<decltype(std::get<0>(t))>,
        std::decay_t<decltype(std::get<1>(t))>,
        std::decay_t<decltype(std::get<2>(t))>
    >;

    switch(index) {
        case 0: return VariantType(std::get<0>(t));
        case 1: return VariantType(std::get<1>(t));
        case 2: return VariantType(std::get<2>(t));
        default: throw std::out_of_range("tuple索引超出范围");
    }
}

int main() {
    auto t = std::make_tuple(1, "Foo", 3.14);
    size_t target_idx = 1; // 运行时变量
    try {
        auto elem = get_tuple_element(t, target_idx);
        // 用std::visit处理variant中的值
        std::visit([](auto&& val) { std::cout << "获取到的元素：" << val << "\n"; }, elem);
    } catch (const std::exception& e) {
        std::cerr << e.what() << "\n";
    }
}

3. 编译期生成索引分支（适合元素较多的tuple）

通过std::index_sequence自动生成所有可能的索引分支，不用手动写每个case：

#include <iostream>
#include <string>
#include <tuple>
#include <utility>
#include <variant>
#include <stdexcept>

// 内部实现函数：利用索引序列生成分支
template<typename Tuple, size_t... Is>
auto get_tuple_element_impl(Tuple&& t, size_t index, std::index_sequence<Is...>) {
    using VariantType = std::variant<std::decay_t<decltype(std::get<Is>(t))>...>;

    // 遍历每个编译期索引，匹配运行时index
    auto match_index = [&](auto I) -> VariantType {
        if (index == I) {
            return VariantType(std::get<I>(std::forward<Tuple>(t)));
        }
        throw std::out_of_range("tuple索引超出范围");
    };

    // 折叠表达式调用每个索引的匹配逻辑
    (match_index(Is), ...);
    // 到这里说明没匹配到，抛出异常
    throw std::out_of_range("tuple索引超出范围");
}

// 对外接口函数
template<typename Tuple>
auto get_tuple_element(Tuple&& t, size_t index) {
    constexpr size_t tuple_size = std::tuple_size_v<std::decay_t<Tuple>>;
    if (index >= tuple_size) {
        throw std::out_of_range("tuple索引超出范围");
    }
    return get_tuple_element_impl(
        std::forward<Tuple>(t),
        index,
        std::make_index_sequence<tuple_size>{}
    );
}

int main() {
    auto t = std::make_tuple(1, "Foo", 3.14, true);
    size_t target_idx = 3;
    try {
        auto elem = get_tuple_element(t, target_idx);
        std::visit([](auto&& val) { std::cout << "获取到的元素：" << val << "\n"; }, elem);
    } catch (const std::exception& e) {
        std::cerr << e.what() << "\n";
    }
}

内容的提问来源于stack exchange，提问作者Bob