std::tuple<Types...>::operator=

 

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)

 

tuple& operator=( const tuple& other );	(1)	(seit C++11) (constexpr seit C++20)
constexpr const tuple& operator=( const tuple& other ) const;	(2)	(seit C++23)
tuple& operator=( tuple&& other ) noexcept(/* siehe unten */);	(3)	(seit C++11) (constexpr seit C++20)
constexpr const tuple& operator=( tuple&& other ) const;	(4)	(seit C++23)
template< class... UTypes > tuple& operator=( const tuple<UTypes...>& other );	(5)	(seit C++11) (constexpr seit C++20)
template< class... UTypes > constexpr const tuple& operator=( const tuple<UTypes...>& other ) const;	(6)	(seit C++23)
template< class... UTypes > tuple& operator=( tuple<UTypes...>&& other );	(7)	(seit C++11) (constexpr seit C++20)
template< class... UTypes > constexpr const tuple& operator=( tuple<UTypes...>&& other ) const;	(8)	(seit C++23)
template< class E1, class E2 > tuple& operator=( const std::pair<E1, E2>& p );	(9)	(seit C++11) (constexpr seit C++20)
template< class E1, class E2 > constexpr const tuple& operator=( const std::pair<E1, E2>& p ) const;	(10)	(seit C++23)
template< class E1, class E2 > tuple& operator=( std::pair<E1, E2>&& p );	(11)	(seit C++11) (constexpr seit C++20)
template< class E1, class E2 > constexpr const tuple& operator=( std::pair<E1, E2>&& p ) const;	(12)	(seit C++23)
template< tuple-like UTuple > constexpr tuple& operator=( UTuple&& u );	(13)	(seit C++23)
template< tuple-like UTuple > constexpr const tuple& operator=( UTuple&& u ) const;	(14)	(seit C++23)

Ersetzt den Inhalt des Tupels durch den Inhalt eines anderen Tupel-ähnlichen Objekts.

In den folgenden Beschreibungen sei

• i ein Index im Bereich [​0​, sizeof...(Types)),
• Ti der i-te Typ im Klassen-Template-Parameterpack Types und
• Ui der i-te Typ in einem Funktions-Template-Parameterpack namens UTypes,

wobei die Indizierung bei Null beginnt.

1) Zuweisungsoperator durch Kopie. Weist jedes Element von other dem entsprechenden Element von *this zu.

Diese Überladung ist als gelöscht definiert, es sei denn, std::is_copy_assignable<Ti>::value ist true für alle Ti.

2) Zuweisungsoperator durch Kopie für einen qualifizierten konstanten Operanden. Weist jedes Element von other dem entsprechenden Element von *this zu.

Diese Überladung nimmt nur an der Overload-Auflösung teil, wenn std::is_copy_assignable_v<const Ti> für alle Ti true ist.

3) Zuweisungsoperator durch Verschieben. Für alle i wird std::forward<Ti>(std::get<i>(other)) dem std::get<i>(*this) zugewiesen.

Diese Überladung nimmt nur an der Overload-Auflösung teil, wenn std::is_move_assignable<Ti>::value für alle Ti true ist.

4) Zuweisungsoperator durch Verschieben für einen qualifizierten konstanten Operanden. Für alle i wird std::forward<Ti>(std::get<i>(other)) dem std::get<i>(*this) zugewiesen.

Diese Überladung nimmt nur an der Overload-Auflösung teil, wenn std::is_assignable_v<const Ti&, Ti> für alle Ti true ist.

5) Für alle i wird std::get<i>(other) dem std::get<i>(*this) zugewiesen.

Diese Überladung nimmt nur an der Overload-Auflösung teil, wenn sizeof...(Types) == sizeof...(UTypes) und std::is_assignable<Ti&, const Ui&>::value für alle entsprechenden Typenpaare Ti und Ui true ist.

6) Für alle i wird std::get<i>(other) dem std::get<i>(*this) zugewiesen.

Diese Überladung nimmt nur an der Overload-Auflösung teil, wenn sizeof...(Types) == sizeof...(UTypes) und std::is_assignable_v<const Ti&, const Ui&> für alle entsprechenden Typenpaare Ti und Ui true ist.

7) Für alle i wird std::forward<Ui>(std::get<i>(other)) dem std::get<i>(*this) zugewiesen.

Diese Überladung nimmt nur an der Overload-Auflösung teil, wenn sizeof...(Types) == sizeof...(UTypes) und std::is_assignable<Ti&, Ui>::value für alle entsprechenden Typenpaare Ti und Ui true ist.

8) Für alle i wird std::forward<Ui>(std::get<i>(other)) dem std::get<i>(*this) zugewiesen.

Diese Überladung nimmt nur an der Overload-Auflösung teil, wenn sizeof...(Types) == sizeof...(UTypes) und std::is_assignable_v<const Ti&, Ui> für alle entsprechenden Typenpaare Ti und Ui true ist.

9) Weist p.first dem ersten Element von *this und p.second dem zweiten Element von *this zu.

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn

• sizeof...(Types) == 2,
• std::is_assignable<T0&, const E1&>::value ist true und
• std::is_assignable<T1&, const E2&>::value ist true.

10) Weist p.first dem ersten und p.second dem zweiten Element zu.

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn

• sizeof...(Types) == 2,
• std::is_assignable_v<const T0&, const E1&> ist true und
• std::is_assignable_v<const T1&, const E2&> ist true.

11) Weist std::forward<E1>(p.first) dem ersten und std::forward<E2>(p.second) dem zweiten Element von *this zu.

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn

• sizeof...(Types) == 2,
• std::is_assignable_v<T0&, E1> ist true und
• std::is_assignable_v<T1&, E2> ist true.

12) Weist std::forward<E1>(p.first) dem ersten und std::forward<E2>(p.second) dem zweiten Element zu.

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn

• sizeof...(Types) == 2,
• std::is_assignable_v<const T0&, E1> ist true und
• std::is_assignable_v<const T1&, E2> ist true.

13) Für alle i wird std::get<i>(std::forward<UTuple>(u)) dem std::get<i>(*this) zugewiesen.

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn

• std::same_as<std::remove_cvref_t<UTuple>, std::tuple> ist false,
• std::remove_cvref_t<UTuple> ist keine Spezialisierung von std::ranges::subrange,
• sizeof...(Types) gleich std::tuple_size_v<std::remove_cvref_t<UTuple>> ist, und
• std::is_assignable_v<Ti&, decltype(std::get<i>(std::forward<UTuple>(u)))> ist für alle i true.

14) Für alle i wird std::get<i>(std::forward<UTuple>(u)) dem std::get<i>(*this) zugewiesen.

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn

• std::same_as<std::remove_cvref_t<UTuple>, std::tuple> ist false,
• std::remove_cvref_t<UTuple> ist keine Spezialisierung von std::ranges::subrange,
• sizeof...(Types) gleich std::tuple_size_v<std::remove_cvref_t<UTuple>> ist, und
• std::is_assignable_v<const Ti&, decltype(std::get<i>(std::forward<UTuple>(u)))> ist für alle i true.

Parameter

Sonstiges	-	Tupel, dessen Inhalt dieses Tupel ersetzen soll
p	-	Paar, dessen Inhalt dieses 2-Tupel ersetzen soll
u	-	Tupel-ähnliches Objekt, dessen Inhalt dieses Tupel ersetzen soll

Rückgabewert

*this

Ausnahmen

1,2) Kann implementierungsdefinierte Ausnahmen auslösen, wenn die Zuweisung eines der Typen in Types eine Ausnahme auslöst.

3)

noexcept-Spezifikation:  

noexcept(

    std::is_nothrow_move_assignable<T0>::value &&
    std::is_nothrow_move_assignable<T1>::value &&
    std::is_nothrow_move_assignable<T2>::value &&
    ...

)

4-14) Kann implementierungsdefinierte Ausnahmen auslösen, wenn die Zuweisung eines der Typen in Types eine Ausnahme auslöst.

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <string>
#include <string_view>
#include <tuple>
#include <utility>
#include <vector>
 
// helper function to print std::vector<int>
std::ostream& operator<<(std::ostream& os, std::vector<int> const& v)
{
    os << '{';
    for (std::size_t t = 0; t != v.size(); ++t)
        os << v[t] << (t + 1 < v.size() ? ", " : "");
    return os << '}';
}
 
// helpers to print a tuple of any size
template<class... Args>
void print_tuple(std::string_view name, const std::tuple<Args...>& t)
{
    std::cout << name << " = {";
    std::apply([&](auto&& arg, auto&&... args)
    {
        std::cout << arg;
        ((std::cout << ", " << args), ...);
    }, t);
    std::cout << '}';
}
 
template<class Tuple1, class Tuple2>
void print_tuples(std::string_view name1, const Tuple1& t1,
                  std::string_view name2, const Tuple2& t2)
{
    print_tuple(name1, t1);
    std::cout << ", ";
    print_tuple(name2, std::tuple(t2));
    std::cout << "\n\n";
}
 
int main()
{
    // Tuple to tuple examples //
    std::tuple<int, std::string, std::vector<int>>
        t1{1, "alpha", {1, 2, 3}},
        t2{2, "beta", {4, 5}};
    print_tuples("1) t1", t1, "t2", t2);
 
    // Normal copy assignment
    // operator=( const tuple& other );
    t1 = t2;
    print_tuples("2) t1 = t2;\n   t1", t1, "t2", t2);
 
    // Normal move assignment
    // operator=( tuple&& other );
    t1 = std::move(t2);
    print_tuples("3) t1 = std::move(t2);\n   t1", t1, "t2", t2);
 
    // Converting copy assignment
    // operator=( const tuple<UTypes...>& other );
    std::tuple<short, const char*, std::vector<int>> t3{3, "gamma", {6, 7, 8}};
    t1 = t3;
    print_tuples("4) t1 = t3;\n   t1", t1, "t3", t3);
 
    // Converting move assignment
    // operator=( tuple<UTypes...>&& other );
    t1 = std::move(t3);
    print_tuples("5) t1 = std::move(t3);\n   t1", t1, "t3", t3);
 
    // Pair to tuple examples //
    std::tuple<std::string, std::vector<int>> t4{"delta", {10, 11, 12}};
    std::pair<const char*, std::vector<int>> p1{"epsilon", {14, 15, 16}};
    print_tuples("6) t4", t4, "p1", p1);
 
    // Converting copy assignment from std::pair
    // operator=( const std::pair<U1, U2>& p );
    t4 = p1;
    print_tuples("7) t4 = p1;\n   t4", t4, "p1", p1);
 
    // Converting move assignment from std::pair
    // operator=( std::pair<U1, U2>&& p );
    t4 = std::move(p1);
    print_tuples("8) t4 = std::move(p1);\n   t4", t4, "p1", p1);
}

Mögliche Ausgabe

1) t1 = {1, alpha, {1, 2, 3}}, t2 = {2, beta, {4, 5}}
 
2) t1 = t2;
   t1 = {2, beta, {4, 5}}, t2 = {2, beta, {4, 5}}
 
3) t1 = std::move(t2);
   t1 = {2, beta, {4, 5}}, t2 = {2, , {}}
 
4) t1 = t3;
   t1 = {3, gamma, {6, 7, 8}}, t3 = {3, gamma, {6, 7, 8}}
 
5) t1 = std::move(t3);
   t1 = {3, gamma, {6, 7, 8}}, t3 = {3, gamma, {}}
 
6) t4 = {delta, {10, 11, 12}}, p1 = {epsilon, {14, 15, 16}}
 
7) t4 = p1;
   t4 = {epsilon, {14, 15, 16}}, p1 = {epsilon, {14, 15, 16}}
 
8) t4 = std::move(p1);
   t4 = {epsilon, {14, 15, 16}}, p1 = {epsilon, {}}

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 2729	C++11	operator= war unbeschränkt und könnte zu unnötigem undefiniertem Verhalten führen	eingeschränkt

Siehe auch

(Konstruktor)	konstruiert ein neues tuple (public member function)
operator=	weist den Inhalt zu (Member-Funktion von std::pair<T1,T2>)