Namespaces
Variants

std:: get (std::variant)

From cppreference.net
C++
Utilities library
std::variant
Défini dans l'en-tête <variant>
(1) (depuis C++17)
template < std:: size_t I, class ... Types >

constexpr std:: variant_alternative_t < I, std:: variant < Types... >> &

get ( std:: variant < Types... > & v ) ;
template < std:: size_t I, class ... Types >

constexpr std:: variant_alternative_t < I, std:: variant < Types... >> &&

get ( std:: variant < Types... > && v ) ;
template < std:: size_t I, class ... Types >

constexpr const std:: variant_alternative_t < I, std:: variant < Types... >> &

get ( const std:: variant < Types... > & v ) ;
template < std:: size_t I, class ... Types >

constexpr const std:: variant_alternative_t < I, std:: variant < Types... >> &&

get ( const std:: variant < Types... > && v ) ;
(2) (depuis C++17)
template < class T, class ... Types >
constexpr T & get ( std:: variant < Types... > & v ) ;
template < class T, class ... Types >
constexpr T && get ( std:: variant < Types... > && v ) ;
template < class T, class ... Types >
constexpr const T & get ( const std:: variant < Types... > & v ) ;
template < class T, class ... Types >
constexpr const T && get ( const std:: variant < Types... > && v ) ;
1) Accesseur de valeur basé sur l'index : Si v. index ( ) == I , retourne une référence à la valeur stockée dans v . Sinon, lance std::bad_variant_access . L'appel est mal formé si I n'est pas un index valide dans le variant.
2) Accesseur de valeur basé sur le type : Si v contient l'alternative T , retourne une référence à la valeur stockée dans v . Sinon, lance std::bad_variant_access . L'appel est mal formé si T n'est pas un élément unique de Types... .

Table des matières

Paramètres du modèle

I - index à rechercher
T - type unique à rechercher
Types... - types constituant le variant

Paramètres

v - un variant

Valeur de retour

Référence à la valeur stockée dans la variante.

Exceptions

1,2) Lance std::bad_variant_access en cas d'erreurs.

Exemple

Exécuter ce code 
#include <iostream>
#include <string>
#include <variant>
int main()
{
    std::variant<int, float> v{12}, w;
    std::cout << std::get<int>(v) << '\n';
    w = std::get<int>(v);
    w = std::get<0>(v); // même effet que la ligne précédente
//  std::get<double>(v); // erreur : pas de double dans [int, float]
//  std::get<3>(v);      // erreur : les valeurs d'index valides sont 0 et 1
    try
    {
        w = 42.0f;
        std::cout << std::get<float>(w) << '\n'; // ok, affiche 42
        w = 42;
        std::cout << std::get<float>(w) << '\n'; // lève une exception
    }
    catch (std::bad_variant_access const& ex)
    {
        std::cout << ex.what() << ": w contenait int, pas float\n";
    }
}

Sortie possible : 

12
42
Unexpected index: w contained int, not float

Voir aussi

(C++17)
obtient un pointeur vers la valeur d'un variant pointé en fonction de l'index ou du type (s'il est unique), retourne null en cas d'erreur
(modèle de fonction)
(C++11)
accède à un élément spécifié d'un tuple
(modèle de fonction)
(C++11)
accède à un élément d'un array
(modèle de fonction)
(C++11)
accède à un élément d'une pair
(modèle de fonction)
(C++20)
obtient un itérateur ou un sentinelle d'un std::ranges::subrange
(modèle de fonction)
(C++26)
obtient une référence vers la partie réelle ou imaginaire d'un std::complex
(modèle de fonction)