Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::get: accesso a elemento tuple-like o variant

std::get seleziona un elemento tramite indice costante o tipo univoco e restituisce un riferimento preservando categoria e const.

Versione: C++23

Sintassi

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> offre famiglie di overload per std::tuple, std::pair, std::array e std::variant; std::get<T> vale per tuple, pair e variant quando T compare esattamente una volta. L’indice da zero è costante a compile time. Il risultato è un riferimento: un lvalue produce T& o const T&, un rvalue il corrispondente riferimento rvalue.

L’esempio legge l’indice 0 e il tipo std::string dalla tuple, poi std::string dall’alternativa attiva del variant; stampa quindi 7 blue ready. Assegnare attraverso il riferimento di una tuple non const modifica l’elemento memorizzato, senza copie.

Un indice fuori intervallo o un tipo non presente esattamente una volta è errore di compilazione. Per std::variant, un get<I>/get<T> altrimenti valido lancia std::bad_variant_access se è attiva un’altra alternativa. Se il mancato match è normale, usa std::get_if o std::holds_alternative. Il riferimento non deve sopravvivere all’oggetto sorgente.

Esempi

#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';
}

Risultato

7 blue ready

std::get → 7 blue ready

Fonti