std::tuple

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Dienstprogramm-Bibliotheken

Sprachunterstützung Typunterstützung (Basistypen, RTTI) Bibliotheks-Feature-Test-Makros (C++20) Programm-Dienstprogramme Variadische Funktionen initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine-Unterstützung (C++20) Vertragsunterstützung (C++26) Drei-Wege-Vergleich three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Allgemeine Hilfsmittel Funktionsobjekte Bit-Manipulation (C++20) bitset hash (C++11) Relationale Operatoren (in C++20 veraltet) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Ganzzahl-Vergleichsfunktionen cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap und Typ-Operationen swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Gemeinsame Vokabulartypen pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

std::tuple

Memberfunktionen

tuple::tuple

tuple::operator=

tuple::swap

Nicht-Member-Funktionen

make_tuple

tie

forward_as_tuple

tuple_cat

operator==operator!=operator<operator<=operator>operator>=operator<=> (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)(C++20)

swap(std::tuple)

get(std::tuple)

Hilfskonzepte

tuple-ähnlich (C++23)

Hilfsklassen

tuple_size<std::tuple>

tuple_element<std::tuple>

uses_allocator<std::tuple>

basic_common_reference<std::tuple> (C++23)

common_type<std::tuple> (C++23)

formatter<std::tuple> (C++23)

ignorieren

Deduktions-Guides(C++17)

 

Definiert in der Header-Datei <tuple>
template< class... Types > class tuple;		(seit C++11)

Die Klassenvorlage std::tuple ist eine Sammlung heterogener Werte fester Größe. Sie ist eine Verallgemeinerung von std::pair.

Wenn std::is_trivially_destructible<Ti>::value für jedes Ti in Types true ist, ist der Destruktor von std::tuple trivial.

Wenn ein Programm eine explizite oder partielle Spezialisierung von std::tuple deklariert, ist das Programm ill-formed (keine Diagnose erforderlich).

Template-Parameter

Types...

-

die Typen der Elemente, die das Tupel speichert. Eine leere Liste wird unterstützt.

Member-Funktionen

(Konstruktor)	konstruiert ein neues tuple (public member function)
operator=	weist den Inhalt eines tuple einem anderen zu (public member function)
swap	tauscht den Inhalt zweier tuples (public member function)

Nicht-Member-Funktionen

make_tuple (C++11)	erstellt ein tuple-Objekt vom Typ, der durch die Argumenttypen definiert ist (function template)
tie (C++11)	erstellt ein Tupel aus Lvalue-Referenzen oder entpackt ein Tupel in einzelne Objekte (Funktionsvorlage)
forward_as_tuple (C++11)	erstellt ein tuple aus Forwarding-Referenzen (function template)
tuple_cat (C++11)	erstellt ein tuple durch Verkettung beliebig vieler Tupel (function template)
get(std::tuple) (C++11)	greift auf ein Tupel-Element gemäß Spezifikation zu (function template)
operator==operator!=operator<operator<=operator>operator>=operator<=> (entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)	vergleicht die Werte im Tupel lexikographisch (function template)
std::swap(std::tuple) (C++11)	spezialisiert den Algorithmus std::swap (function template)

Hilfskonzepte

tuple-ähnlichpair-ähnlich (C++23)

spezifiziert, dass ein Typ das Tupel-Protokoll implementiert (std::get, std::tuple_element, std::tuple_size) (nur zu Ausstellungszwecken*)

Hilfsklassen

std::tuple_size<std::tuple> (C++11)	ermittelt die Größe eines tuple (class template specialization)
std::tuple_element<std::tuple> (C++11)	ermittelt den Typ des spezifizierten Elements (class template specialization)
std::uses_allocator<std::tuple> (C++11)	spezialisiert das std::uses_allocator Typ-Trait (class template specialization)
std::basic_common_reference<tuple-like> (C++23)	ermittelt den gemeinsamen Referenztyp eines tuple und eines tuple-like Typs (class template specialization)
std::common_type<tuple-like> (C++23)	ermittelt den gemeinsamen Typ eines tuple und eines tuple-like Typs (class template specialization)
std::formatter<std::tuple> (C++23)	Formatierungsunterstützung für tuple (Klassenvorlagenspezialisierung)
ignorieren (C++11)	Platzhalter zum Überspringen eines Elements beim Entpacken eines tuple mit tie (constant)

Hilfsspezialisierungen

template< class... Ts > constexpr bool enable_nonlocking_formatter_optimization<std::tuple<Ts...>>  = (enable_nonlocking_formatter_optimization<Ts> && ...);		(seit C++23)

Diese Spezialisierung von std::enable_nonlocking_formatter_optimization ermöglicht eine effiziente Implementierung von std::print und std::println zum Drucken eines tuple-Objekts, wenn jeder Elementtyp dies zulässt.

Hinweise

Da die "Form" eines Tupels – seine Größe, die Typen seiner Elemente und die Reihenfolge dieser Typen – Teil seiner Typsignatur ist, müssen alle zur Kompilierzeit verfügbar sein und können nur von anderen zur Kompilierzeit ausgewerteten Informationen abhängen. Das bedeutet, dass viele bedingte Operationen auf Tupeln – insbesondere bedingtes Voranstellen/Anhängen und Filtern – nur möglich sind, wenn die Bedingungen zur Kompilierzeit ausgewertet werden können. Zum Beispiel ist es mit einem std::tuple<int, double, int> möglich, nach Typen zu filtern – z. B. die Rückgabe eines std::tuple<int, int> –, aber nicht danach zu filtern, ob jedes Element positiv ist (was eine andere Typsignatur abhängig von Laufzeitwerten des Tupels hätte), es sei denn, alle Elemente wären selbst constexpr.

Als Workaround kann man mit Tupeln von std::optional arbeiten, aber es gibt immer noch keine Möglichkeit, die Größe basierend auf Laufzeitinformationen anzupassen.

Bis N4387 (angewendet als Fehlerbericht für C++11) konnte eine Funktion kein Tupel mit Copy-List-Initialisierung zurückgeben.

std::tuple<int, int> foo_tuple()
{
    return {1, -1};  // Error until N4387
    return std::tuple<int, int>{1, -1}; // Always works
    return std::make_tuple(1, -1); // Always works
}

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <stdexcept>
#include <string>
#include <tuple>
 
std::tuple<double, char, std::string> get_student(int id)
{
    switch (id)
    {
        case 0: return {3.8, 'A', "Lisa Simpson"};
        case 1: return {2.9, 'C', "Milhouse Van Houten"};
        case 2: return {1.7, 'D', "Ralph Wiggum"};
        case 3: return {0.6, 'F', "Bart Simpson"};
    }
 
    throw std::invalid_argument("id");
}
 
int main()
{
    const auto student0 = get_student(0);
    std::cout << "ID: 0, "
              << "GPA: " << std::get<0>(student0) << ", "
              << "grade: " << std::get<1>(student0) << ", "
              << "name: " << std::get<2>(student0) << '\n';
 
    const auto student1 = get_student(1);
    std::cout << "ID: 1, "
              << "GPA: " << std::get<double>(student1) << ", "
              << "grade: " << std::get<char>(student1) << ", "
              << "name: " << std::get<std::string>(student1) << '\n';
 
    double gpa2;
    char grade2;
    std::string name2;
    std::tie(gpa2, grade2, name2) = get_student(2);
    std::cout << "ID: 2, "
              << "GPA: " << gpa2 << ", "
              << "grade: " << grade2 << ", "
              << "name: " << name2 << '\n';
 
    // C++17 structured binding:
    const auto [gpa3, grade3, name3] = get_student(3);
    std::cout << "ID: 3, "
              << "GPA: " << gpa3 << ", "
              << "grade: " << grade3 << ", "
              << "name: " << name3 << '\n';
}

Ausgabe

ID: 0, GPA: 3.8, grade: A, name: Lisa Simpson
ID: 1, GPA: 2.9, grade: C, name: Milhouse Van Houten
ID: 2, GPA: 1.7, grade: D, name: Ralph Wiggum
ID: 3, GPA: 0.6, grade: F, name: Bart Simpson

Fehlerberichte

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 2796	C++11	Die Trivialität des Destruktors von std::tuple war nicht spezifiziert.	spezifiziert
LWG 3990	C++11	Ein Programm konnte eine explizite oder partielle Spezialisierung von std::tuple deklarieren.	Das Programm ist in diesem Fall ill-formed (keine Diagnose erforderlich).

Referenzen

• C++23 Standard (ISO/IEC 14882:2024)

• 22.4 Tuples [tuple]

• C++20 Standard (ISO/IEC 14882:2020)

• 20.5 Tuples [tuple]

• C++17 Standard (ISO/IEC 14882:2017)

• 23.5 Tuples [tuple]

• C++14 Standard (ISO/IEC 14882:2014)

• 20.4 Tuples [tuple]

• C++11 Standard (ISO/IEC 14882:2011)

• 20.4 Tuples [tuple]

Siehe auch

pair	implementiert ein binäres Tupel, d. h. ein Paar von Werten (Klassenvorlage)