为何std::get()无法用于获取std::vector的元素？

Great question! The core reason comes down to compile-time vs. runtime behavior of these containers, and how std::get() is designed to operate.

Let’s start with the basics: std::get() is a template function that depends entirely on compile-time constant indices. The index you pass (like <1>) has to be known by the compiler when it builds your code—this isn’t something that can be figured out while your program is running.

Why it works for array, pair, and tuple #

All three of these containers have fixed, compile-time known sizes:

• std::array<int, 4>: The size 4 is a template parameter, so the compiler knows exactly how many elements exist at compile time. Using std::get<1>(a1) is safe because the index 1 is a constant, and the compiler can immediately verify it’s within bounds.
• std::pair<int, int>: By definition, it only has 2 elements. std::get<0> and std::get<1> are hardcoded valid indices the compiler can validate upfront.
• std::tuple<int, float, float>: The number of elements is part of its template type (3 elements here), so again, the compiler knows the valid index range before your program runs.

Why it doesn't work for std::vector #

std::vector is a dynamic container: its size is determined at runtime. You can add or remove elements while your program is running, so the compiler has no way of knowing how many elements the vector will have when it’s building your code.

If you tried to write something like std::get<1>(my_vector), even if you think the vector has at least 2 elements, the compiler can’t guarantee that. Worse, if you tried to use a runtime variable as the index (like std::get<i>(my_vector) where i is an int set while the program runs), the compiler can’t generate code for that—since std::get() requires the index to be a compile-time template parameter.

For std::vector, you use runtime-safe accessors like operator[] (unchecked) or at() (bounds-checked) instead, since these work with runtime indices.

Your formatted code example #

Here’s your code with proper formatting, plus what happens if you try to add vector access with std::get():

#include <iostream>
#include <array>
#include <vector>
#include <tuple>
#include <utility> // std::pair

using namespace std;

int main() {
    array<int, 4> a1{3,4,5,67};
    pair<int,int> p1{5,6};
    tuple<int,float,float> t1{6,5.5,4.5};
    
    cout << std::get<1>(a1) << endl;   // Works: outputs 4
    cout << std::get<1>(p1) << endl;   // Works: outputs 6
    cout << std::get<1>(t1) << endl;   // Works: outputs 5.5
    
    vector<int> v1{10, 20, 30};
    // cout << std::get<1>(v1) << endl; // ERROR! Compiler will reject this line
    cout << v1[1] << endl; // Correct way: uses runtime index, outputs 20
}

The compiler error for the std::get<1>(v1) line would look something like:

error: no matching function for call to ‘get(std::vector&)’
note: candidate: template<long unsigned int _Idx, class _Tp, long unsigned int _Nm> constexpr _Tp& std::get(std::array<_Tp, _Nm>&)
note: template argument deduction/substitution failed:
note: mismatched types ‘std::array<_Tp, _Nm>’ and ‘std::vector’

This makes sense—std::get() doesn’t have an overload for std::vector, because it can’t enforce the compile-time index requirement that the function relies on.

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