Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::get : accès à un élément tuple-like ou variant

std::get sélectionne un élément par indice constant ou type unique et renvoie une référence conservant catégorie de valeur et constance.

Version : C++23

Syntaxe

template<std::size_t I, class... Types>
constexpr decltype(auto) std::get(std::tuple<Types...>& t); // cv/ref overloads

template<class T, class... Types>
constexpr decltype(auto) std::get(std::tuple<Types...>& t); // cv/ref overloads

// Corresponding overload families exist for std::pair, std::array, and std::variant.

std::get<I> possède des familles de surcharges pour std::tuple, std::pair, std::array et std::variant ; std::get<T> s’applique à tuple, pair et variant lorsque T apparaît exactement une fois. L’indice, partant de zéro, est constant à la compilation. Le résultat est une référence : un lvalue donne T& ou const T&, un rvalue la référence rvalue correspondante.

L’exemple lit l’indice 0 et le type std::string du tuple, puis std::string de l’alternative active du variant ; il affiche donc 7 blue ready. Une affectation via la référence d’un tuple non const modifierait l’élément stocké, sans copie.

Un indice hors limites ou un type qui n’apparaît pas exactement une fois est une erreur de compilation. Pour std::variant, un get<I>/get<T> bien formé lance std::bad_variant_access si une autre alternative est active. Si l’échec est normal, utilisez std::get_if ou std::holds_alternative. Ne gardez jamais la référence au-delà de la durée de vie de l’objet source.

Exemples

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

int main() {
    std::tuple<int, std::string> row{7, "blue"};
    std::variant<int, std::string> state = std::string{"ready"};

    std::cout << std::get<0>(row) << ' '
              << std::get<std::string>(row) << ' '
              << std::get<std::string>(state) << '\n';
}

Résultat

7 blue ready

std::get → 7 blue ready

Sources