Namespaces
Variants

std:: get (std::tuple)

From cppreference.net
C++
Utilities library
std::tuple
Definido en el encabezado <tuple>
template < std:: size_t I, class ... Types >

typename std:: tuple_element < I, std:: tuple < Types... >> :: type &

get ( std:: tuple < Types... > & t ) noexcept ;
(1) (desde C++11)
(constexpr desde C++14)
template < std:: size_t I, class ... Types >

typename std:: tuple_element < I, std:: tuple < Types... >> :: type &&

get ( std:: tuple < Types... > && t ) noexcept ;
(2) (desde C++11)
(constexpr desde C++14)
template < std:: size_t I, class ... Types >

const typename std:: tuple_element < I, std:: tuple < Types... >> :: type &

get ( const std:: tuple < Types... > & t ) noexcept ;
(3) (desde C++11)
(constexpr desde C++14)
template < std:: size_t I, class ... Types >

const typename std:: tuple_element < I, std:: tuple < Types... >> :: type &&

get ( const std:: tuple < Types... > && t ) noexcept ;
(4) (desde C++11)
(constexpr desde C++14)
template < class T, class ... Types >
constexpr T & get ( std:: tuple < Types... > & t ) noexcept ;
(5) (desde C++14)
template < class T, class ... Types >
constexpr T && get ( std:: tuple < Types... > && t ) noexcept ;
(6) (desde C++14)
template < class T, class ... Types >
constexpr const T & get ( const std:: tuple < Types... > & t ) noexcept ;
(7) (desde C++14)
template < class T, class ... Types >
constexpr const T && get ( const std:: tuple < Types... > && t ) noexcept ;
(8) (desde C++14)
1-4) Extrae el I th elemento de la tupla. I debe ser un valor entero en [ ​ 0 ​ , sizeof... ( Types ) ) .
5-8) Extrae el elemento de la tupla t cuyo tipo es T . Falla en compilar a menos que la tupla tenga exactamente un elemento de ese tipo.

Contenidos

Parámetros

t - tupla cuyo contenido extraer

Valor de retorno

Una referencia al elemento seleccionado de t .

Notas

Macro de prueba de características Valor Std Característica
__cpp_lib_tuples_by_type 201304L (C++14) Direccionamiento de tuplas por tipo ( 5-8 )

Ejemplo

Ejecutar este código 
#include <cassert>
#include <iostream>
#include <string>
#include <tuple>
int main()
{
    auto x = std::make_tuple(1, "Foo", 3.14);
    // Acceso basado en índice
    std::cout << "( " << std::get<0>(x)
              << ", " << std::get<1>(x)
              << ", " << std::get<2>(x)
              << " )\n";
    // Acceso basado en tipo (desde C++14)
    std::cout << "( " << std::get<int>(x)
              << ", " << std::get<const char*>(x)
              << ", " << std::get<double>(x)
              << " )\n";
    const std::tuple<int, const int, double, double> y(1, 2, 6.9, 9.6);
    const int& i1 = std::get<int>(y); // OK: no es ambiguo
    assert(i1 == 1);
    const int& i2 = std::get<const int>(y); // OK: no es ambiguo
    assert(i2 == 2);
    // const double& d = std::get<double>(y); // Error: mal formado (ambiguo)
    // Nota: std::tie y el enlace estructurado pueden ser
    // utilizados para desempaquetar una tupla en objetos individuales.
}

Salida: 

( 1, Foo, 3.14 )
( 1, Foo, 3.14 )

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 2485 C++11 (por índice)
C++14 (por tipo) 		no existen sobrecargas para const tuple && se agregaron estas sobrecargas ( ( 4 ) y ( 8 ) )

Véase también

(C++11)
accede a un elemento de un array
(plantilla de función)
(C++11)
accede a un elemento de un pair
(plantilla de función)
(C++17)
lee el valor del variant dado el índice o el tipo (si el tipo es único), lanza excepción en caso de error
(plantilla de función)
(C++20)
obtiene un iterador o centinela de un std::ranges::subrange
(plantilla de función)
(C++26)
obtiene una referencia a la parte real o imaginaria de un std::complex
(plantilla de función)
(C++11)
crea un tuple de referencias a lvalue o desempaqueta un tuple en objetos individuales
(plantilla de función)
Structured binding (C++17) vincula los nombres especificados a subobjetos o elementos de tuple del inicializador